home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb.new / gdb-3.98 / bfd.mips / coffcode.h < prev    next >
Encoding:
Text File  |  1991-08-23  |  92.2 KB  |  3,236 lines
  1. /* Support for Intel 960 COFF and Motorola 88k BCS COFF (and maybe others)
  2.    Copyright (C) 1990-1991 Free Software Foundation, Inc.
  3.    Written by Cygnus Support.
  4.  
  5. This file is part of BFD, the Binary File Descriptor library.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /*doc*
  22. @section coff backends
  23.  
  24. BFD supports a number of different flavours of coff format. The major
  25. difference between formats are the sizes and alignments of fields in
  26. structures on disk, and the occasional extra field.
  27.  
  28. Coff in all its varieties is implimented with a few common files and a
  29. number of implementation specific files. For example, The 88k bcs coff
  30. format is implemented in the file @code{m88k-bcs.c}. This file
  31. @code{#include}s @code{m88k-bcs.h} which defines the external
  32. structure of the coff format for the 88k, and @code{internalcoff.h}
  33. which defines the internal structure. @code{m88k-bcs.c} also defines
  34. the relocations used by the 88k format @xref{Relocations}. Then the
  35. major portion of coff code is included (@code{coffcode.h}) which
  36. defines the methods used to act upon the types defined in
  37. @code{m88k-bcs.h} and @code{internalcoff.h}. 
  38.  
  39. The Intel i960 processor version of coff is implemented in
  40. @code{icoff.c}. This file has the same structure as 
  41. @code{m88k-bcs.c}, except that it includes @code{intel-coff.h} rather
  42. than @code{m88k-bcs.h}. 
  43.  
  44. @subsection Porting To A New Version of Coff
  45.  
  46. The recommended method is to select from the existing implimentations
  47. the version of coff which is most like the one you want to use, for
  48. our purposes, we'll say that i386 coff is the one you select, and that
  49. your coff flavour is called foo. Copy the @code{i386coff.c} to @code{foocoff.c},
  50. copy @code{../include/i386coff.h} to @code{../include/foocoff.h} and
  51. add the lines to @code{targets.c} and @code{Makefile.in} so that your
  52. new back end is used. 
  53.  
  54. Alter the shapes of the structures in @code{../include/foocoff.h} so
  55. that they match what you need. You will probably also have to add
  56. @code{#ifdef}s to the code in @code{internalcoff.h} and
  57. @code{coffcode.h} if your version of coff is too wild.
  58.  
  59. You can verify that your new bfd backend works quite simply by
  60. building @code{objdump} from the @code{binutils} directory, and
  61. making sure that its version of what's going on at your host systems
  62. idea (assuming it has the pretty standard coff dump utility (usually
  63. called @code{att-dump} or just @code{dump})) are the same.
  64.  
  65. Then clean up your code, and send what you've done to Cygnus. Then your stuff
  66. will be in the next release, and you won't have to keep integrating
  67. it.
  68.  
  69. @subsection How The Coff Backend Works
  70.  
  71. @subsubsection Bit Twiddling
  72. Each flavour of coff supported in bfd has its own header file
  73. descibing the external layout of the structures. There is also an
  74. internal description of the coff layout (in @code{internalcoff.h})
  75. file (@code{}). A major function of the coff backend is swapping the
  76. bytes and twiddling the bits to translate the external form of the
  77. structures into the normal internal form. This is all performed in the
  78. @code{bfd_swap}_@i{thing}_@i{direction} routines. Some elements are
  79. different sizes between different versions of coff, it is the duty of
  80. the coff version specific include file to override the definitions of
  81. various packing routines in @code{coffcode.h}. Eg the size of line
  82. number entry in coff is sometimes 16 bits, and sometimes 32 bits.
  83. @code{#define}ing @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will
  84. select the correct one. No doubt, some day someone will find a version
  85. of coff which has a varying field size not catered for at the moment.
  86. To port bfd, that person will have to add more @code{#defines}.
  87.  
  88. Three of the bit twiddling routines are exported to @code{gdb};
  89. @code{coff_swap_aux_in}, @code{coff_swap_sym_in} and
  90. @code{coff_swap_linno_in}. @code{GDB} reads the symbol table on its
  91. own, but uses bfd to fix things up.
  92.  
  93. @subsubsection Symbol Reading
  94. The simple canonical form for symbols used by bfd is not rich enough
  95. to keep all the information available in a coff symbol table. The back
  96. end gets around this by keeping the original symbol table around,
  97. "behind the sceens". 
  98.  
  99. When a symbol table is requested (through a call to
  100. @code{bfd_canonicalize_symtab}, a request gets through to
  101. @code{get_normalized_symtab}. This reads the symbol table from the
  102. coff file and swaps all the structures inside into the internal form.
  103. It also fixes up all the pointers in the table (represented in the file
  104. by offsets from the first symbol in the table) into physical pointers
  105. to elements in the new internal table. This involves some work since
  106. the meanings of fields changes depending upon context; a field that is a
  107. pointer to another structure in the symbol table at one moment may be
  108. the size in bytes of a structure in the next.
  109.  
  110. Another pass is made over the table. All symbols which mark file names
  111. (@code{C_FILE} symbols) are modified so that the internal string
  112. points to the value in the auxent (the real filename) rather than the
  113. normal text associated with the symbol (@code{".file"}).
  114.  
  115. At this time the symbol names are moved around. Coff stores all
  116. symbols less than nine characters long physically within the symbol
  117. table, longer strings are kept at the end of the file in the string
  118. table. This pass moves all strings into memory, and replaces them with
  119. pointers to the strings.
  120.  
  121. The symbol table is massaged once again, this time to create the
  122. canonical table used by the bfd application. Each symbol is inspected
  123. in turn, and a decision made (using the @code{sclass} field) about the
  124. various flags to set in the @code{asymbol} @xref{Symbols}. The
  125. generated canonical table shares strings with the hidden internal
  126. symbol table.
  127.  
  128. Any linenumbers are read from the coff file too, and attatched to the
  129. symbols which own the functions the linenumbers belong to.
  130.  
  131. @subsubsection Symbol Writing
  132. Writing a symbol to a coff file which didn't come from a coff file
  133. will lose any debugging information. The @code{asymbol} structure
  134. remembers the bfd from which was born, and on output the back end
  135. makes sure that the same destination target as source target is
  136. present.
  137.  
  138. When the symbols have come from a coff file then all the debugging
  139. information is preserved. 
  140.  
  141. Symbol tables are provided for writing to the back end in a vector of
  142. pointers to pointers. This allows applications like the linker to
  143. accumulate and output large symbol tables without having to do too
  144. much byte copying.
  145.  
  146. The symbol table is not output to a writable bfd until it is closed. 
  147. The order of operations on the canonical symbol table at that point
  148. are:
  149. @table @code
  150. @item coff_renumber_symbols
  151. This function runs through the provided symbol table and patches each
  152. symbol marked as a file place holder (@code{C_FILE}) to point to the
  153. next file place holder in the list. It also marks each @code{offset}
  154. field in the list with the offset from the first symbol of the current
  155. symbol. 
  156.  
  157. Another function of this procedure is to turn the canonical value form
  158. of bfd into the form used by coff. Internally, bfd expects symbol
  159. values to be offsets from a section base; so a symbol physically at
  160. 0x120, but in a section starting at 0x100, would have the value 0x20.
  161. Coff expects symbols to contain their final value, so symbols have
  162. their values changed at this point to reflect their sum with their
  163. owning section. Note that this transformation uses the
  164. @code{output_section} field of the @code{asymbol}'s @code{asection}
  165. @xref{Sections}.
  166. @item coff_mangle_symbols
  167. This routine runs though the provided symbol table and uses the
  168. offsets generated by the previous pass and the pointers generated when
  169. the symbol table was read in to create the structured hierachy
  170. required by coff. It changes each pointer to a symbol to an index into
  171. the symbol table of the symbol being referenced.
  172. @item coff_write_symbols
  173. This routine runs through the symbol table and patches up the symbols
  174. from their internal form into the coff way, calls the bit twiddlers
  175. and writes out the tabel to the file.
  176. @end table
  177. */
  178.  
  179. /*proto*
  180.  
  181. The hidden information for an asymbol is:
  182.  
  183. *+++
  184.  
  185. $ typedef struct coff_ptr_struct
  186. $ {
  187.  
  188. Remembers the offset from the first symbol in the file for this
  189. symbol. Generated by @code{coff_renumber_symbols}.
  190.  
  191. $   unsigned int offset;
  192.  
  193. Should the tag field of this symbol be renumbered.
  194. Created by @code{coff_pointerize_aux}.
  195.  
  196. $   char fix_tag;
  197.  
  198. Should the endidx field of this symbol be renumbered.
  199. Created by @code{coff_pointerize_aux}.
  200.  
  201. $   char fix_end;
  202.  
  203. The container for the symbol structure as read and translated from the file.
  204.  
  205. $   union {
  206. $     union internal_auxent auxent;
  207. $     struct internal_syment syment;
  208. $   } u;
  209. $ } combined_entry_type;
  210. $
  211.  
  212. *---
  213.  
  214. Each canonical asymbol really looks like this:
  215.  
  216. *+++
  217.  
  218. $ typedef struct coff_symbol_struct
  219. $ {
  220.  
  221. The actual symbol which the rest of bfd works with
  222.  
  223. $   asymbol symbol;
  224.  
  225. A pointer to the hidden information for this symbol
  226.  
  227. $   combined_entry_type *native;
  228.  
  229. A pointer to the linenumber information for this symbol
  230.  
  231. $   struct lineno_cache_entry *lineno;
  232. $ } coff_symbol_type;
  233.  
  234. *---
  235.  
  236. */
  237.  
  238. /* $Id: coffcode.h,v 1.13 1991/07/31 16:57:31 gnu Exp $ */
  239. /* Most of this hacked by Steve Chamberlain, steve@cygnus.com */
  240.  
  241. /* Align an address upward to a boundary, expressed as a number of bytes.
  242.    E.g. align to an 8-byte boundary with argument of 8.  */
  243. #define ALIGN(this, boundary) \
  244.   ((( (this) + ((boundary) -1)) & (~((boundary)-1))))
  245.  
  246. /* Align an address upward to a power of two.  Argument is the power
  247.    of two, e.g. 8-byte alignment uses argument of 3 (8 == 2^3).  */
  248. #define    i960_align(addr, align)    \
  249.     ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
  250.  
  251.  
  252. #define PUTWORD bfd_h_put_32
  253. #define PUTHALF bfd_h_put_16
  254.  
  255. #ifndef GET_FCN_LNNOPTR
  256. #define GET_FCN_LNNOPTR(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
  257. #endif
  258.  
  259. #ifndef GET_FCN_ENDNDX
  260. #define GET_FCN_ENDNDX(abfd, ext)  bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
  261. #endif
  262.  
  263. #ifndef PUT_FCN_LNNOPTR
  264. #define PUT_FCN_LNNOPTR(abfd, in, ext)  PUTWORD(abfd,  in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
  265. #endif
  266. #ifndef PUT_FCN_ENDNDX
  267. #define PUT_FCN_ENDNDX(abfd, in, ext) PUTWORD(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx)
  268. #endif
  269. #ifndef GET_LNSZ_LNNO
  270. #define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno)
  271. #endif
  272. #ifndef GET_LNSZ_SIZE
  273. #define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size)
  274. #endif
  275. #ifndef PUT_LNSZ_LNNO
  276. #define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno)
  277. #endif
  278. #ifndef PUT_LNSZ_SIZE
  279. #define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size)
  280. #endif
  281. #ifndef GET_SCN_SCNLEN 
  282. #define GET_SCN_SCNLEN(abfd,  ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen)
  283. #endif
  284. #ifndef GET_SCN_NRELOC
  285. #define GET_SCN_NRELOC(abfd,  ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc)
  286. #endif
  287. #ifndef GET_SCN_NLINNO
  288. #define GET_SCN_NLINNO(abfd, ext)  bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno)
  289. #endif
  290. #ifndef PUT_SCN_SCNLEN 
  291. #define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen)
  292. #endif
  293. #ifndef PUT_SCN_NRELOC
  294. #define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc)
  295. #endif
  296. #ifndef PUT_SCN_NLINNO
  297. #define PUT_SCN_NLINNO(abfd,in, ext)  bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno)
  298. #endif
  299.  
  300.  
  301.  
  302. /* void warning(); */
  303.  
  304. /* 
  305.  * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the 
  306.  * incoming SEC_* flags.  The inverse of this function is styp_to_sec_flags().
  307.  * NOTE: If you add to/change this routine, you should mirror the changes
  308.  *     in styp_to_sec_flags().
  309.  */
  310. static long 
  311. DEFUN(sec_to_styp_flags, (sec_name, sec_flags),
  312.     CONST char *        sec_name    AND
  313.     flagword    sec_flags)
  314. {
  315.     long styp_flags = 0;
  316.  
  317.     if (!strcmp(sec_name, _TEXT)) {
  318.     return((long)STYP_TEXT);
  319.     } else if (!strcmp(sec_name, _DATA)) {
  320.     return((long)STYP_DATA);
  321.     } else if (!strcmp(sec_name, _BSS)) {
  322.     return((long)STYP_BSS);
  323.     } 
  324.  
  325. /* Try and figure out what it should be */
  326.    if (sec_flags & SEC_CODE) styp_flags = STYP_TEXT; 
  327.    if (sec_flags & SEC_DATA) styp_flags = STYP_DATA; 
  328.    else if (sec_flags & SEC_READONLY) 
  329. #ifdef STYP_LIT    /* 29k readonly text/data section */
  330.        styp_flags = STYP_LIT; 
  331. #else
  332.        styp_flags = STYP_TEXT; 
  333. #endif    /* STYP_LIT */
  334.    else if (sec_flags & SEC_LOAD) styp_flags = STYP_TEXT;
  335.  
  336.    if (styp_flags == 0) styp_flags = STYP_BSS;
  337.  
  338.    return(styp_flags);
  339. }
  340. /* 
  341.  * Return a word with SEC_* flags set to represent the incoming
  342.  * STYP_* flags (from scnhdr.s_flags).   The inverse of this 
  343.  * function is sec_to_styp_flags().  
  344.  * NOTE: If you add to/change this routine, you should mirror the changes
  345.  *      in sec_to_styp_flags().
  346.  */
  347. static flagword 
  348. DEFUN(styp_to_sec_flags, (styp_flags),
  349.     long    styp_flags)
  350. {
  351.     flagword    sec_flags=0;
  352.  
  353.     if ((styp_flags & STYP_TEXT) || (styp_flags & STYP_DATA))
  354.     sec_flags = (SEC_LOAD | SEC_ALLOC);
  355.     else if (styp_flags & STYP_BSS)
  356.     sec_flags = SEC_ALLOC;
  357.  
  358. #ifdef STYP_LIT        /* A29k readonly text/data section type */
  359.     if ((styp_flags & STYP_LIT) == STYP_LIT)
  360.     sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
  361. #endif  /* STYP_LIT */
  362.  
  363.     return(sec_flags);
  364. }
  365.  
  366. static int
  367. DEFUN(get_index,(symbol),
  368.       asymbol        *symbol)
  369. {
  370.     return (int) symbol->value;
  371. }
  372.  
  373. static void
  374. DEFUN(set_index,(symbol, idx),
  375.       asymbol        *symbol AND
  376.       unsigned int    idx)
  377. {
  378.     symbol->value = idx;
  379. }
  380.  
  381.  
  382. /*  **********************************************************************
  383. Here are all the routines for swapping the structures seen in the
  384. outside world into the internal forms. 
  385. */
  386.  
  387.  
  388. static void
  389. DEFUN(bfd_swap_reloc_in,(abfd, reloc_src, reloc_dst),
  390.       bfd            *abfd AND
  391.       RELOC *reloc_src AND
  392.       struct internal_reloc *reloc_dst)
  393. {
  394.   reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
  395.   reloc_dst->r_symndx = bfd_h_get_32(abfd, (bfd_byte *) reloc_src->r_symndx);
  396.   reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
  397. #if M88
  398.   reloc_dst->r_offset = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_offset);
  399. #endif
  400. }
  401.  
  402.  
  403. static void
  404. DEFUN(bfd_swap_reloc_out,(abfd, reloc_src, reloc_dst),
  405.       bfd            *abfd AND
  406.       struct internal_reloc *reloc_src AND
  407.       struct external_reloc *reloc_dst)
  408. {
  409.   bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
  410.   bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
  411.   bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *) reloc_dst->r_type);
  412. #if M88
  413.   bfd_h_put_16(abfd, reloc_src->r_offset, (bfd_byte *) reloc_dst->r_offset);
  414. #endif
  415.  
  416. }
  417.  
  418. static void
  419. DEFUN(bfd_swap_filehdr_in,(abfd, filehdr_src, filehdr_dst),
  420.       bfd            *abfd AND
  421.       FILHDR         *filehdr_src AND
  422.       struct internal_filehdr *filehdr_dst)
  423. {
  424.   filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
  425.   filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
  426.   filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
  427.   filehdr_dst->f_symptr = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_symptr);
  428.   filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
  429.   filehdr_dst->f_opthdr = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_opthdr);
  430.   filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
  431. }
  432.  
  433. static  void 
  434. DEFUN(bfd_swap_filehdr_out,(abfd, filehdr_in, filehdr_out),
  435.       bfd            *abfd AND
  436.       struct internal_filehdr *filehdr_in AND
  437.       FILHDR         *filehdr_out)
  438. {
  439.   bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
  440.   bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
  441.   bfd_h_put_32(abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
  442.   bfd_h_put_32(abfd, filehdr_in->f_symptr, (bfd_byte *) filehdr_out->f_symptr);
  443.   bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
  444.   bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
  445.   bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
  446. }
  447.  
  448.  
  449. #ifndef NO_COFF_SYMBOLS
  450.  
  451. static void 
  452. DEFUN(coff_swap_sym_in,(abfd, ext1, in1),
  453.       bfd            *abfd AND
  454.       PTR ext1 AND
  455.       PTR in1)
  456. {
  457.   SYMENT *ext = (SYMENT *)ext1;
  458.   struct internal_syment      *in = (struct internal_syment *)in1;
  459.  
  460.   if( ext->e.e_name[0] == 0) {
  461.     in->_n._n_n._n_zeroes = 0;
  462.     in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
  463.   }
  464.   else {
  465.     memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
  466.   }
  467.   in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
  468.   in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
  469.   if (sizeof(ext->e_type) == 2){
  470.     in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
  471.   }
  472.   else {
  473.     in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
  474.   }
  475.   in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
  476.   in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
  477. }
  478.  
  479. static void 
  480. DEFUN(coff_swap_sym_out,(abfd,in,  ext),
  481.       bfd            *abfd AND
  482.       struct internal_syment      *in AND
  483.       SYMENT *ext)
  484. {
  485.   if(in->_n._n_name[0] == 0) {
  486.     bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
  487.     bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *)  ext->e.e.e_offset);
  488.   }
  489.   else {
  490.     memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
  491.   }
  492.   bfd_h_put_32(abfd,  in->n_value , (bfd_byte *) ext->e_value);
  493.   bfd_h_put_16(abfd,  in->n_scnum , (bfd_byte *) ext->e_scnum);
  494.   if (sizeof(ext->e_type) == 2) 
  495.       {
  496.     bfd_h_put_16(abfd,  in->n_type , (bfd_byte *) ext->e_type);
  497.       }
  498.   else
  499.       {
  500.     bfd_h_put_32(abfd,  in->n_type , (bfd_byte *) ext->e_type);
  501.       }
  502.   bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
  503.   bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);
  504. }
  505.  
  506. static void
  507. DEFUN(coff_swap_aux_in,(abfd, ext1, type, class, in1),
  508.       bfd            *abfd AND
  509.       PTR ext1 AND
  510.       int             type AND
  511.       int             class AND
  512.       PTR in1)
  513. {
  514.   AUXENT    *ext = (AUXENT *)ext1;
  515.   union internal_auxent  *in = (union internal_auxent *)in1;
  516.   switch (class) {
  517.   case C_FILE:
  518.     if (ext->x_file.x_fname[0] == 0) {
  519.       in->x_file.x_n.x_zeroes = 0;
  520.       in->x_file.x_n.x_offset  = bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
  521.     } else {
  522.       memcpy (in->x_file.x_fname, ext->x_file.x_fname,
  523.           sizeof (in->x_file.x_fname));
  524.     }
  525.  
  526.     break;
  527.   case C_STAT:
  528. #ifdef C_LEAFSTAT
  529.   case C_LEAFSTAT:
  530. #endif
  531.   case C_HIDDEN:
  532.     if (type == T_NULL) {
  533.       in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
  534.       in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
  535.       in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
  536.       break;
  537.     }
  538.   default:
  539.     in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
  540. #ifndef NO_TVNDX
  541.     in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
  542. #endif
  543.  
  544.     if (ISARY(type) || class == C_BLOCK) {
  545.       in->x_sym.x_fcnary.x_ary.x_dimen[0] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
  546.       in->x_sym.x_fcnary.x_ary.x_dimen[1] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
  547.       in->x_sym.x_fcnary.x_ary.x_dimen[2] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
  548.       in->x_sym.x_fcnary.x_ary.x_dimen[3] = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
  549.     }
  550.       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR(abfd, ext);
  551.       in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX(abfd, ext);
  552.  
  553.     if (ISFCN(type)) {
  554.       in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
  555.     }
  556.     else {
  557.       in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
  558.       in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
  559.     }
  560.   }
  561. }
  562.  
  563. static void
  564. DEFUN(coff_swap_aux_out,(abfd, in, type, class, ext),
  565.   bfd   *abfd AND
  566.   union internal_auxent *in AND
  567.   int    type AND
  568.   int    class AND
  569.   AUXENT *ext)
  570. {
  571.   switch (class) {
  572.   case C_FILE:
  573.     if (in->x_file.x_fname[0] == 0) {
  574.       PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes );
  575.       PUTWORD(abfd, in->x_file.x_n.x_offset, (bfd_byte *) ext->x_file.x_n.x_offset);
  576.     }
  577.     else {
  578.       memcpy ( ext->x_file.x_fname,in->x_file.x_fname,
  579.           sizeof (in->x_file.x_fname));
  580.     }    
  581.     break;
  582.   case C_STAT:
  583. #ifdef C_LEAFSTAT
  584.   case C_LEAFSTAT:
  585. #endif
  586.   case C_HIDDEN:
  587.     if (type == T_NULL) {
  588.  
  589.       PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
  590.       PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
  591.       PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
  592.       break;
  593.     }
  594.   default:
  595.     PUTWORD(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
  596. #ifndef NO_TVNDX
  597.     PUTWORD(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
  598. #endif
  599.  
  600.     if (ISFCN(type)) {
  601.       PUTWORD(abfd, in->x_sym.x_misc.x_fsize, (bfd_byte *)  ext->x_sym.x_misc.x_fsize);
  602.       PUT_FCN_LNNOPTR(abfd,  in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
  603.       PUT_FCN_ENDNDX(abfd,  in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
  604.     }
  605.     else {
  606.  
  607.       if (ISARY(type) || class == C_BLOCK) {
  608.     bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
  609.     bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
  610.     bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
  611.     bfd_h_put_16(abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], (bfd_byte *)ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
  612.  
  613.       }
  614.     PUT_LNSZ_LNNO(abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
  615.     PUT_LNSZ_SIZE(abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
  616.  
  617.       PUT_FCN_LNNOPTR(abfd,  in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
  618.       PUT_FCN_ENDNDX(abfd,  in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
  619.  
  620.  
  621.     }
  622.   }
  623. }
  624.  
  625. #endif /* NO_COFF_SYMBOLS */
  626.  
  627. #ifndef NO_COFF_LINENOS
  628.  
  629. static void
  630. DEFUN(coff_swap_lineno_in,(abfd, ext1, in1),
  631.       bfd            *abfd AND
  632.       PTR ext1 AND
  633.       PTR in1)
  634. {
  635.   LINENO *ext = (LINENO *)ext1;
  636.   struct internal_lineno      *in = (struct internal_lineno *)in1;
  637.  
  638.   in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
  639. #if defined(M88)
  640.   in->l_lnno = bfd_h_get_32(abfd, (bfd_byte *) ext->l_lnno);
  641. #else
  642.   in->l_lnno = bfd_h_get_16(abfd, (bfd_byte *) ext->l_lnno);
  643. #endif
  644. }
  645.  
  646. static void
  647. DEFUN(coff_swap_lineno_out,(abfd, in, ext),
  648.       bfd            *abfd AND
  649.       struct internal_lineno      *in AND
  650.       struct external_lineno *ext)
  651. {
  652.   PUTWORD(abfd, in->l_addr.l_symndx, (bfd_byte *) ext->l_addr.l_symndx);
  653. #if defined(M88)
  654.   PUTWORD(abfd, in->l_lnno, (bfd_byte *) ext->l_lnno);
  655. #else
  656.   PUTHALF(abfd, in->l_lnno, (bfd_byte *) ext->l_lnno);
  657. #endif
  658. }
  659.  
  660. #endif /* NO_COFF_LINENOS */
  661.  
  662.  
  663. static void 
  664. DEFUN(bfd_swap_aouthdr_in,(abfd, aouthdr_ext1, aouthdr_int1),
  665.       bfd            *abfd AND
  666.       PTR aouthdr_ext1 AND
  667.       PTR aouthdr_int1)
  668. {
  669.   AOUTHDR        *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
  670.   struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
  671.  
  672.   aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
  673.   aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
  674.   aouthdr_int->tsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tsize);
  675.   aouthdr_int->dsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->dsize);
  676.   aouthdr_int->bsize = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->bsize);
  677.   aouthdr_int->entry = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->entry);
  678.   aouthdr_int->text_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->text_start);
  679.   aouthdr_int->data_start = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->data_start);
  680. #ifdef I960
  681.   aouthdr_int->tagentries = bfd_h_get_32(abfd, (bfd_byte *) aouthdr_ext->tagentries);
  682. #endif
  683. }
  684.  
  685. static void 
  686. DEFUN(bfd_swap_aouthdr_out,(abfd, aouthdr_in, aouthdr_out),
  687.       bfd            *abfd AND
  688.       struct internal_aouthdr *aouthdr_in AND
  689.       AOUTHDR        *aouthdr_out)
  690. {
  691.   bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->magic);
  692.   bfd_h_put_16(abfd, aouthdr_in->vstamp, (bfd_byte *) aouthdr_out->vstamp);
  693.   bfd_h_put_32(abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->tsize);
  694.   bfd_h_put_32(abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->dsize);
  695.   bfd_h_put_32(abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->bsize);
  696.   bfd_h_put_32(abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->entry);
  697.   bfd_h_put_32(abfd, aouthdr_in->text_start, (bfd_byte *) aouthdr_out->text_start);
  698.   bfd_h_put_32(abfd, aouthdr_in->data_start, (bfd_byte *) aouthdr_out->data_start);
  699. #ifdef I960
  700.   bfd_h_put_32(abfd, aouthdr_in->tagentries, (bfd_byte *) aouthdr_out->tagentries);
  701. #endif
  702. }
  703.  
  704. static void 
  705. DEFUN(coff_swap_scnhdr_in,(abfd, scnhdr_ext, scnhdr_int),
  706.       bfd            *abfd AND
  707.       SCNHDR         *scnhdr_ext AND
  708.       struct internal_scnhdr *scnhdr_int)
  709. {
  710.   memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
  711.   scnhdr_int->s_vaddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
  712.   scnhdr_int->s_paddr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_paddr);
  713.   scnhdr_int->s_size = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_size);
  714.   scnhdr_int->s_scnptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
  715.   scnhdr_int->s_relptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_relptr);
  716.   scnhdr_int->s_lnnoptr = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
  717.   scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
  718. #if defined(M88)
  719.   scnhdr_int->s_nreloc = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
  720.   scnhdr_int->s_nlnno = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
  721. #else
  722.   scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc);
  723.   scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno);
  724. #endif
  725. #ifdef I960
  726.   scnhdr_int->s_align = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_align);
  727. #endif
  728. }
  729.  
  730. static void 
  731. DEFUN(swap_scnhdr_out,(abfd, scnhdr_int, scnhdr_ext),
  732.       bfd            *abfd AND
  733.       struct internal_scnhdr *scnhdr_int AND
  734.       SCNHDR         *scnhdr_ext)
  735. {
  736.   memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
  737.   PUTWORD(abfd, scnhdr_int->s_vaddr, (bfd_byte *) scnhdr_ext->s_vaddr);
  738.   PUTWORD(abfd, scnhdr_int->s_paddr, (bfd_byte *) scnhdr_ext->s_paddr);
  739.   PUTWORD(abfd, scnhdr_int->s_size, (bfd_byte *) scnhdr_ext->s_size);
  740.   PUTWORD(abfd, scnhdr_int->s_scnptr, (bfd_byte *) scnhdr_ext->s_scnptr);
  741.   PUTWORD(abfd, scnhdr_int->s_relptr, (bfd_byte *) scnhdr_ext->s_relptr);
  742.   PUTWORD(abfd, scnhdr_int->s_lnnoptr, (bfd_byte *) scnhdr_ext->s_lnnoptr);
  743.   PUTWORD(abfd, scnhdr_int->s_flags, (bfd_byte *) scnhdr_ext->s_flags);
  744. #if defined(M88)
  745.   PUTWORD(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
  746.   PUTWORD(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
  747. #else
  748.   PUTHALF(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno);
  749.   PUTHALF(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc);
  750. #endif
  751.  
  752. #if defined(I960) 
  753.   PUTWORD(abfd, scnhdr_int->s_align, (bfd_byte *) scnhdr_ext->s_align);
  754. #endif
  755. }
  756.  
  757.  
  758. /* **********************************************************************/
  759. /* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
  760.  \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
  761.  be \0-terminated.
  762.  */
  763. static char *
  764. DEFUN(copy_name,(abfd, name, maxlen),
  765.       bfd *abfd AND
  766.       char *name AND
  767.       int maxlen)
  768. {
  769.   int  len;
  770.   char *newname;
  771.  
  772.   for (len = 0; len < maxlen; ++len) {
  773.     if (name[len] == '\0') {
  774.       break;
  775.     }
  776.   }
  777.  
  778.   if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) {
  779.     bfd_error = no_memory;
  780.     return (NULL);
  781.   }
  782.   strncpy(newname, name, len);
  783.   newname[len] = '\0';
  784.   return newname;
  785. }
  786.  
  787. /*
  788.    initialize a section structure with information peculiar to this
  789.    particular implementation of coff
  790. */
  791.  
  792. static          boolean
  793. DEFUN(coff_new_section_hook,(abfd_ignore, section_ignore),
  794.       bfd            *abfd_ignore AND
  795.       asection       *section_ignore)
  796. {
  797.   section_ignore->alignment_power = abfd_ignore->xvec->align_power_min;
  798.   return true;
  799. }
  800.  
  801. /* Take a section header read from a coff file (in HOST byte order),
  802.    and make a BFD "section" out of it.  */
  803. static          boolean
  804. DEFUN(make_a_section_from_file,(abfd, hdr),
  805.       bfd            *abfd AND
  806.       struct internal_scnhdr  *hdr)
  807. {
  808.     asection       *return_section;
  809.  
  810.     {
  811.     /* Assorted wastage to null-terminate the name, thanks AT&T! */
  812.     char *name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
  813.     if (name == NULL) {
  814.         bfd_error = no_memory;
  815.         return false;
  816.     }
  817.     strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
  818.     name[sizeof (hdr->s_name)] = 0;
  819.  
  820.     return_section = bfd_make_section(abfd, name);
  821.     }
  822.  
  823.     /* s_paddr is presumed to be = to s_vaddr */
  824. #define assign(to, from) return_section->to = hdr->from
  825.     assign(vma, s_vaddr);
  826.     /* assign (vma, s_vaddr); */
  827.     assign(size, s_size);
  828.     assign(filepos, s_scnptr);
  829.     assign(rel_filepos, s_relptr);
  830.     assign(reloc_count, s_nreloc);
  831. #ifdef I960
  832.     {
  833.     /* FIXME, use a temp var rather than alignment_power */
  834.     assign(alignment_power, s_align);
  835.     {
  836.         unsigned int    i;
  837.         for (i = 0; i < 32; i++) {
  838.         if ((1 << i) >= (int) (return_section->alignment_power)) {
  839.             return_section->alignment_power = i;
  840.             break;
  841.         }
  842.         }
  843.     }
  844.     }
  845. #endif
  846.     assign(line_filepos, s_lnnoptr);
  847.     /*
  848.        return_section->linesize =   hdr->s_nlnno * sizeof (struct lineno);
  849.     */
  850.  
  851.     return_section->lineno_count = hdr->s_nlnno;
  852.     return_section->userdata = NULL;
  853.     return_section->next = (asection *) NULL;
  854.     return_section->flags = styp_to_sec_flags(hdr->s_flags);
  855.  
  856.  
  857.     if (hdr->s_nreloc != 0)
  858.     return_section->flags |= SEC_RELOC;
  859.     /* FIXME: should this check 'hdr->s_size > 0' */
  860.     if (hdr->s_scnptr != 0)
  861.     return_section->flags |= SEC_HAS_CONTENTS;
  862.     return true;
  863. }
  864. static          boolean
  865. DEFUN(coff_mkobject,(abfd),
  866.       bfd            *abfd)
  867. {
  868.   set_tdata (abfd, bfd_zalloc (abfd,sizeof(coff_data_type)));
  869.   if (coff_data(abfd) == 0) {
  870.     bfd_error = no_memory;
  871.     return false;
  872.   }
  873.   coff_data(abfd)->relocbase = 0;
  874.   return true;
  875. }
  876.  
  877. static
  878. bfd_target     *
  879. DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a),
  880.     bfd            *abfd AND
  881.     unsigned        nscns AND
  882.   struct internal_filehdr *internal_f AND
  883.   struct internal_aouthdr *internal_a)
  884. {
  885.   coff_data_type *coff;
  886.     
  887.   size_t          readsize;    /* length of file_info */
  888.   SCNHDR *external_sections;
  889.     
  890.   /* Build a play area */
  891.   if (coff_mkobject(abfd) != true)
  892.     return 0;
  893.   coff = coff_data(abfd);
  894.     
  895.     
  896.   external_sections = (SCNHDR *)bfd_alloc(abfd, readsize = (nscns * SCNHSZ));
  897.  
  898.   if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) {
  899.     goto fail;
  900.   }
  901.     
  902.     
  903.   /* Now copy data as required; construct all asections etc */
  904.   coff->symbol_index_slew = 0;
  905.   coff->relocbase =0;
  906.   coff->raw_syment_count = 0;
  907.   coff->raw_linenos = 0;
  908.   coff->raw_syments = 0;
  909.   coff->sym_filepos =0;
  910.   coff->flags = internal_f->f_flags;
  911.   if (nscns != 0) {
  912.     unsigned int    i;
  913.     for (i = 0; i < nscns; i++) {
  914.       struct internal_scnhdr tmp;
  915.       coff_swap_scnhdr_in(abfd, external_sections + i, &tmp);
  916.       make_a_section_from_file(abfd,&tmp);
  917.     }
  918.   }
  919.   /* Determine the machine architecture and type.  */
  920.   abfd->obj_machine = 0;
  921.   switch (internal_f->f_magic) {
  922. #ifdef I386MAGIC
  923.   case I386MAGIC:
  924.     abfd->obj_arch = bfd_arch_i386;
  925.     abfd->obj_machine = 0;
  926.     break;
  927. #endif
  928.  
  929. #ifdef A29K_MAGIC_BIG 
  930.   case  A29K_MAGIC_BIG:
  931.   case  A29K_MAGIC_LITTLE:
  932.     abfd->obj_arch = bfd_arch_a29k;
  933.     abfd->obj_machine = 0;
  934.     break;
  935. #endif
  936.  
  937. #ifdef MIPS
  938.   case  MIPS_MAGIC_1:
  939.   case  MIPS_MAGIC_2:
  940.   case  MIPS_MAGIC_3:
  941.     abfd->obj_arch = bfd_arch_mips;
  942.     abfd->obj_machine = 0;
  943.     break;
  944. #endif
  945.  
  946. #ifdef MC68MAGIC
  947.   case MC68MAGIC:
  948.   case M68MAGIC:
  949.     abfd->obj_arch = bfd_arch_m68k;
  950.     abfd->obj_machine = 68020;
  951.     break;
  952. #endif
  953. #ifdef MC88MAGIC
  954.   case MC88MAGIC:
  955.   case MC88DMAGIC:
  956.   case MC88OMAGIC:
  957.     abfd->obj_arch = bfd_arch_m88k;
  958.     abfd->obj_machine = 88100;
  959.     break;
  960. #endif
  961. #ifdef I960
  962. #ifdef I960ROMAGIC
  963.   case I960ROMAGIC:
  964.   case I960RWMAGIC:
  965.     abfd->obj_arch = bfd_arch_i960;
  966.     switch (F_I960TYPE & internal_f->f_flags) 
  967.     {
  968.     default:
  969.     case F_I960CORE:
  970.       abfd->obj_machine = bfd_mach_i960_core;
  971.       break;
  972.     case F_I960KB:
  973.       abfd->obj_machine = bfd_mach_i960_kb_sb;
  974.       break;
  975.     case F_I960MC:
  976.       abfd->obj_machine = bfd_mach_i960_mc;
  977.       break;
  978.     case F_I960XA:
  979.       abfd->obj_machine = bfd_mach_i960_xa;
  980.       break;
  981.     case F_I960CA:
  982.       abfd->obj_machine = bfd_mach_i960_ca;
  983.       break;
  984.     case F_I960KA:
  985.       abfd->obj_machine = bfd_mach_i960_ka_sa;
  986.       break;
  987.       
  988.     }
  989.     break;
  990. #endif
  991. #endif
  992.     
  993.   default:            /* Unreadable input file type */
  994.     abfd->obj_arch = bfd_arch_obscure;
  995.     break;
  996.   }
  997.   
  998.   if (!(internal_f->f_flags & F_RELFLG))
  999.     abfd->flags |= HAS_RELOC;
  1000.   if ((internal_f->f_flags & F_EXEC))
  1001.     abfd->flags |= EXEC_P;
  1002.   if (!(internal_f->f_flags & F_LNNO))
  1003.     abfd->flags |= HAS_LINENO;
  1004.   if (!(internal_f->f_flags & F_LSYMS))
  1005.     abfd->flags |= HAS_LOCALS;
  1006.   
  1007.   
  1008.   bfd_get_symcount(abfd) = internal_f->f_nsyms;
  1009.   if (internal_f->f_nsyms)
  1010.     abfd->flags |= HAS_SYMS;
  1011.   
  1012.   coff->sym_filepos = internal_f->f_symptr;
  1013.   
  1014.   
  1015.   
  1016.   coff->symbols = (coff_symbol_type *) NULL;
  1017.   bfd_get_start_address(abfd) = internal_f->f_opthdr ? internal_a->entry : 0;
  1018.   
  1019.   return abfd->xvec;
  1020.  fail:
  1021.   bfd_release(abfd, coff);
  1022.   return (bfd_target *)NULL;
  1023. }
  1024.  
  1025. static bfd_target *
  1026. DEFUN(coff_object_p,(abfd),
  1027.       bfd            *abfd)
  1028. {
  1029.   int   nscns;
  1030.   FILHDR filehdr;
  1031.   AOUTHDR opthdr;
  1032.   struct internal_filehdr internal_f;
  1033.   struct internal_aouthdr internal_a;
  1034.     
  1035.   bfd_error = system_call_error;
  1036.     
  1037.   /* figure out how much to read */
  1038.   if (bfd_read((PTR) &filehdr, 1, FILHSZ, abfd) != FILHSZ)
  1039.     return 0;
  1040.     
  1041.   bfd_swap_filehdr_in(abfd, &filehdr, &internal_f);
  1042.     
  1043.   if (BADMAG(internal_f)) {
  1044.     bfd_error = wrong_format;
  1045.     return 0;
  1046.   }
  1047.   nscns =internal_f.f_nscns;
  1048.     
  1049.   if (internal_f.f_opthdr) {
  1050.     if (bfd_read((PTR) &opthdr, 1,AOUTSZ, abfd) != AOUTSZ) {
  1051.       return 0;
  1052.     }
  1053.     bfd_swap_aouthdr_in(abfd, &opthdr, &internal_a);
  1054.   }
  1055.     
  1056.   /* Seek past the opt hdr stuff */
  1057.   bfd_seek(abfd, internal_f.f_opthdr + FILHSZ, SEEK_SET);
  1058.     
  1059.   /* if the optional header is NULL or not the correct size then
  1060.      quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
  1061.      and Intel 960 readwrite headers (I960WRMAGIC) is that the
  1062.      optional header is of a different size.
  1063.      
  1064.      But the mips keeps extra stuff in it's opthdr, so dont check
  1065.      when doing that
  1066.      */
  1067.     
  1068. #ifndef MIPS    
  1069.   if (internal_f.f_opthdr != 0 && AOUTSZ != internal_f.f_opthdr)
  1070.     return (bfd_target *)NULL;
  1071. #endif
  1072.     
  1073.   return coff_real_object_p(abfd, nscns, &internal_f, &internal_a);
  1074. }
  1075.  
  1076.  
  1077.  
  1078. #ifndef NO_COFF_LINENOS
  1079.  
  1080. static void 
  1081. DEFUN(coff_count_linenumbers,(abfd),
  1082.       bfd            *abfd)
  1083. {
  1084.   unsigned int    limit = bfd_get_symcount(abfd);
  1085.   unsigned int    i;
  1086.   asymbol       **p;
  1087.     {
  1088.       asection       *s = abfd->sections->output_section;
  1089.       while (s) {
  1090.     BFD_ASSERT(s->lineno_count == 0);
  1091.     s = s->next;
  1092.       }
  1093.     }
  1094.     
  1095.     
  1096.   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
  1097.     asymbol        *q_maybe = *p;
  1098.     if (q_maybe->the_bfd->xvec->flavour == bfd_target_coff_flavour_enum) {
  1099.       coff_symbol_type *q = coffsymbol(q_maybe);
  1100.       if (q->lineno) {
  1101.     /*
  1102.       This symbol has a linenumber, increment the owning
  1103.       section's linenumber count
  1104.       */
  1105.     alent          *l = q->lineno;
  1106.     q->symbol.section->output_section->lineno_count++;
  1107.     l++;
  1108.     while (l->line_number) {
  1109.       q->symbol.section->output_section->lineno_count++;
  1110.       l++;
  1111.     }
  1112.       }
  1113.     }
  1114.   }
  1115. }
  1116.  
  1117. #endif /* NO_COFF_LINENOS */
  1118.  
  1119. #ifndef NO_COFF_SYMBOLS
  1120.  
  1121. /* 
  1122. Takes a bfd and a symbol, returns a pointer to the coff specific area
  1123. of the symbol if there is one.
  1124. */
  1125. static coff_symbol_type *
  1126. DEFUN(coff_symbol_from,(abfd, symbol),
  1127.       bfd            *abfd AND
  1128.       asymbol        *symbol)
  1129. {
  1130.   if (symbol->the_bfd->xvec->flavour != bfd_target_coff_flavour_enum) 
  1131.     return (coff_symbol_type *)NULL;
  1132.     
  1133.   if (symbol->the_bfd->tdata == (PTR)NULL)
  1134.     return (coff_symbol_type *)NULL;
  1135.     
  1136.   return  (coff_symbol_type *) symbol;
  1137. }
  1138.  
  1139.  
  1140.  
  1141. static void
  1142. DEFUN(fixup_symbol_value,(coff_symbol_ptr, syment),
  1143. coff_symbol_type *coff_symbol_ptr AND
  1144. struct internal_syment *syment)
  1145. {
  1146.  
  1147.   /* Normalize the symbol flags */
  1148.   if (coff_symbol_ptr->symbol.flags & BSF_FORT_COMM) {
  1149.     /* a common symbol is undefined with a value */
  1150.     syment->n_scnum = N_UNDEF;
  1151.     syment->n_value = coff_symbol_ptr->symbol.value;
  1152.   }
  1153.   else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
  1154.     syment->n_value = coff_symbol_ptr->symbol.value;
  1155.   }
  1156.   else if (coff_symbol_ptr->symbol.flags & BSF_UNDEFINED) {
  1157.     syment->n_scnum = N_UNDEF;
  1158.     syment->n_value = 0;
  1159.   }      
  1160.   else if (coff_symbol_ptr->symbol.flags & BSF_ABSOLUTE) {
  1161.     syment->n_scnum = N_ABS;
  1162.     syment->n_value = coff_symbol_ptr->symbol.value;
  1163.   }      
  1164.   else {
  1165.     syment->n_scnum     = 
  1166.       coff_symbol_ptr->symbol.section->output_section->index+1;
  1167.         
  1168.     syment->n_value = 
  1169.       coff_symbol_ptr->symbol.value +
  1170.     coff_symbol_ptr->symbol.section->output_offset +
  1171.       coff_symbol_ptr->symbol.section->output_section->vma;
  1172.   }
  1173. }
  1174.  
  1175. /* run through all the symbols in the symbol table and work out what
  1176.    their indexes into the symbol table will be when output 
  1177.  
  1178.  Coff requires that each C_FILE symbol points to the next one in the
  1179.  chain, and that the last one points to the first external symbol. We
  1180.  do that here too.
  1181.  
  1182. */
  1183. static void
  1184. DEFUN(coff_renumber_symbols,(bfd_ptr),
  1185.       bfd *bfd_ptr)
  1186. {
  1187.   unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
  1188.   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
  1189.   unsigned int native_index = 0;
  1190.   struct internal_syment *last_file = (struct internal_syment *)NULL;
  1191.   unsigned int symbol_index;
  1192.   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 
  1193.       {
  1194.     coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
  1195.     if (coff_symbol_ptr && coff_symbol_ptr->native) {
  1196.       combined_entry_type *s = coff_symbol_ptr->native;
  1197.       int i;
  1198.  
  1199.       if (s->u.syment.n_sclass == C_FILE) 
  1200.           {
  1201.         if (last_file != (struct internal_syment *)NULL) {
  1202.           last_file->n_value = native_index;
  1203.         }
  1204.         last_file = &(s->u.syment);
  1205.           }
  1206.       else {
  1207.  
  1208.         /* Modify the symbol values according to their section and
  1209.            type */
  1210.  
  1211.         fixup_symbol_value(coff_symbol_ptr, &(s->u.syment));
  1212.       }
  1213.       for (i = 0; i < s->u.syment.n_numaux + 1; i++) {
  1214.         s[i].offset = native_index ++;
  1215.       }
  1216.     }
  1217.     else {
  1218.       native_index++;
  1219.     }
  1220.       }
  1221. }
  1222.  
  1223.  
  1224. /*
  1225.  Run thorough the symbol table again, and fix it so that all pointers to
  1226.  entries are changed to the entries' index in the output symbol table.
  1227.  
  1228. */
  1229. static void 
  1230. DEFUN(coff_mangle_symbols,(bfd_ptr),
  1231.       bfd *bfd_ptr)
  1232. {
  1233.   unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
  1234.   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
  1235.  
  1236.   unsigned int symbol_index;
  1237.  
  1238.  
  1239.   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 
  1240.       {
  1241.     coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
  1242.     if (coff_symbol_ptr && coff_symbol_ptr->native ) {
  1243.       int i;
  1244.       combined_entry_type *s = coff_symbol_ptr->native;
  1245.  
  1246.  
  1247.  
  1248.  
  1249.  
  1250.       for (i = 0; i < s->u.syment.n_numaux ; i++) {
  1251.         combined_entry_type *a = s + i + 1;
  1252.         if (a->fix_tag) {
  1253.           a->u.auxent.x_sym.x_tagndx.l = a->u.auxent.x_sym.x_tagndx.p->offset;
  1254.         }
  1255.         if (a->fix_end) {
  1256.           a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
  1257.         a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
  1258.         }
  1259.  
  1260.       }
  1261.     }
  1262.       }
  1263. }
  1264.  
  1265. #if 0
  1266.     unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
  1267.     asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
  1268.     struct internal_syment *last_tagndx = (struct internal_syment *)NULL;
  1269.     struct internal_syment *last_file = (struct internal_syment *)NULL;
  1270.     struct internal_syment *last_fcn = (struct internal_syment *)NULL;
  1271.     struct internal_syment *block_stack[50];
  1272.     struct internal_syment **last_block = &block_stack[0];
  1273.     boolean first_time = true;  
  1274.     unsigned int symbol_index;
  1275.     unsigned int native_index = 0;
  1276.     
  1277.     for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) {
  1278.       coff_symbol_type *coff_symbol_ptr =
  1279.     coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
  1280.       if (coff_symbol_ptr == (coff_symbol_type *)NULL) {
  1281.     /* 
  1282.       This symbol has no coff information in it, it will take up
  1283.         only one slot in the output symbol table
  1284.           */
  1285.     native_index++;
  1286.       }
  1287.       else {
  1288.     struct internal_syment *syment = coff_symbol_ptr->native;
  1289.     if (syment == (struct internal_syment *)NULL) {
  1290.       native_index++;
  1291.     }
  1292.     else {
  1293.       /* Normalize the symbol flags */
  1294.       if (coff_symbol_ptr->symbol.flags & BSF_FORT_COMM) {
  1295.         /* a common symbol is undefined with a value */
  1296.         syment->n_scnum = N_UNDEF;
  1297.         syment->n_value = coff_symbol_ptr->symbol.value;
  1298.       }
  1299.       else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
  1300.         syment->n_value = coff_symbol_ptr->symbol.value;
  1301.       }
  1302.       else if (coff_symbol_ptr->symbol.flags & BSF_UNDEFINED) {
  1303.         syment->n_scnum = N_UNDEF;
  1304.         syment->n_value = 0;
  1305.       }      
  1306.       else if (coff_symbol_ptr->symbol.flags & BSF_ABSOLUTE) {
  1307.         syment->n_scnum = N_ABS;
  1308.         syment->n_value = coff_symbol_ptr->symbol.value;
  1309.       }      
  1310.       else {
  1311.         syment->n_scnum     = 
  1312.           coff_symbol_ptr->symbol.section->output_section->index+1;
  1313.         
  1314.         syment->n_value = 
  1315.           coff_symbol_ptr->symbol.value +
  1316.         coff_symbol_ptr->symbol.section->output_offset +
  1317.           coff_symbol_ptr->symbol.section->output_section->vma;
  1318.       }
  1319.       
  1320.       
  1321.       /* If this symbol ties up something then do it */
  1322.       
  1323.       if (syment->n_sclass == C_FILE && last_file != (struct internal_syment *)NULL)
  1324.           {
  1325.         last_file->n_value = native_index;
  1326.           }
  1327.       else if ((syment->n_sclass == C_EXT 
  1328.             || syment->n_sclass == C_STAT 
  1329. #ifdef C_LEAFEXT
  1330.             || syment->n_sclass == C_LEAFEXT 
  1331.               || syment->n_sclass == C_LEAFSTAT
  1332. #endif
  1333.           )
  1334.          && last_fcn != (struct internal_syment *)NULL) 
  1335.         {
  1336.           union internal_auxent *auxent = (union internal_auxent *)(last_fcn+1);
  1337.           auxent->x_sym.x_fcnary.x_fcn.x_endndx.l = native_index;
  1338.           last_fcn = (struct internal_syment *)NULL;
  1339.           
  1340.         }
  1341.     else if (syment->n_sclass == C_EOS && last_tagndx != (struct internal_syment*)NULL)
  1342.         {
  1343.           union internal_auxent *auxent = (union internal_auxent *)(last_tagndx+1);
  1344.           /* Remember that we keep the native index in the offset 
  1345.          so patch the beginning of the struct to point to this
  1346.          */
  1347. /*if (last_
  1348.           auxent->x_sym.x_tagndx =    last_tagndx->_n._n_n._n_offset;*/
  1349.           auxent->x_sym.x_fcnary.x_fcn.x_endndx.l = syment->n_numaux + 1 + native_index;
  1350.           /* Now point the eos to the structure */
  1351.           auxent = (union internal_auxent *)(syment+1);
  1352.           auxent->x_sym.x_tagndx.l =  last_tagndx->_n._n_n._n_offset;
  1353.         }
  1354.     else if (syment->n_sclass == C_BLOCK 
  1355.          && coff_symbol_ptr->symbol.name[1] == 'e') 
  1356.         {
  1357.           union internal_auxent *auxent = (union internal_auxent *)((*(--last_block))+1);
  1358.           auxent->x_sym.x_fcnary.x_fcn.x_endndx.l = native_index + syment->n_numaux + 1;
  1359.         }
  1360.     if (syment->n_sclass == C_EXT 
  1361.         && !ISFCN(syment->n_type) 
  1362.         && first_time == true 
  1363.         && last_file != (struct internal_syment *)NULL) {
  1364.       /* This is the first external symbol seen which isn't a 
  1365.          function place it in the last .file entry */
  1366.       last_file->n_value = native_index;
  1367.       first_time = false;
  1368.     }
  1369. #ifdef C_LEAFPROC
  1370.     if (syment->n_sclass == C_LEAFPROC &&
  1371.         syment->n_numaux == 2) {
  1372.       union internal_auxent *auxent = (union internal_auxent *)(syment+2);
  1373.       /* This is the definition of a leaf proc, we'll relocate the 
  1374.          address */
  1375.       auxent->x_bal.x_balntry =       
  1376.         coff_symbol_ptr->symbol.section->output_offset + 
  1377.           coff_symbol_ptr->symbol.section->output_section->vma +
  1378.         auxent->x_bal.x_balntry   ;
  1379.     }
  1380. #endif
  1381.     /* If this symbol needs to be tied up then remember some facts */
  1382.     if (syment->n_sclass == C_FILE) 
  1383.         {
  1384.           last_file = syment;
  1385.         }
  1386.     if (syment->n_numaux != 0) {
  1387.       /*
  1388.         If this symbol would like to point to something in the
  1389.         future then remember where it is 
  1390.         */
  1391.       if (uses_x_sym_x_tagndx_p(bfd_ptr, syment)) {
  1392.         /* 
  1393.           If this is a ref to a structure then we'll tie it up 
  1394.           now - there are never any forward refs for one 
  1395.           */
  1396.         if (syment->n_sclass == C_STRTAG ||
  1397.         syment->n_sclass == C_ENTAG ||
  1398.         syment->n_sclass == C_UNTAG) {
  1399.           last_tagndx = syment;
  1400.         }
  1401.         else {
  1402.           /*
  1403.         This is a ref to a structure - the structure must
  1404.         have been defined within the same file, and previous
  1405.         to this point, so we can deduce the new tagndx
  1406.         directly.
  1407.         */
  1408.           union internal_auxent *auxent = (union internal_auxent *)(syment+1);
  1409.           bfd *bfd_ptr = coff_symbol_ptr->symbol.the_bfd;
  1410.           struct internal_syment *base = obj_raw_syments(bfd_ptr);          
  1411. /*          auxent->x_sym.x_tagndx = base[auxent->x_sym.x_tagndx]._n._n_n._n_offset;*/
  1412.           
  1413.           
  1414.         }
  1415.       }
  1416.       if (ISFCN(syment->n_type)) {
  1417.         last_fcn = syment;
  1418.       }
  1419.       if (syment->n_sclass == C_BLOCK 
  1420.           && coff_symbol_ptr->symbol.name[1] == 'b')
  1421.           {
  1422.         *last_block++ = syment;
  1423.           }
  1424.     }
  1425.     syment->_n._n_n._n_offset = native_index;
  1426.     native_index = native_index + 1 + syment->n_numaux;
  1427.       }
  1428.     }
  1429.   }
  1430. }
  1431.  
  1432.  
  1433. #endif
  1434. static int string_size; 
  1435. static void
  1436. DEFUN(coff_fix_symbol_name,(abfd, symbol, native),
  1437.   bfd *abfd AND
  1438.   asymbol *symbol AND
  1439.   combined_entry_type *native)
  1440. {
  1441.   unsigned int    name_length;
  1442.   union internal_auxent *auxent;
  1443.   char *  name = ( char *)(symbol->name);
  1444.  
  1445.   if (name == (char *) NULL) {
  1446.     /*
  1447.       coff symbols always have names, so we'll make one up
  1448.       */
  1449.  symbol->name = "strange";
  1450.     name = (char *)symbol->name;
  1451.   }
  1452.   name_length = strlen(name);
  1453.           
  1454.   if (native->u.syment.n_sclass == C_FILE) {
  1455.     strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN);
  1456.     auxent = &(native+1)->u.auxent;
  1457.         
  1458. #ifdef COFF_LONG_FILENAMES
  1459.     if (name_length <= FILNMLEN) {
  1460.       strncpy(auxent->x_file.x_fname, name, FILNMLEN);
  1461.     }
  1462.     else {
  1463.       auxent->x_file.x_n.x_offset = string_size + 4;
  1464.       auxent->x_file.x_n.x_zeroes = 0;
  1465.       string_size += name_length + 1;
  1466.     }
  1467. #else
  1468.     strncpy(auxent->x_file.x_fname, name, FILNMLEN);
  1469.     if (name_length > FILNMLEN) {
  1470.       name[FILNMLEN] = '\0';
  1471.     }
  1472. #endif
  1473.   }
  1474.   else
  1475.       {                /* NOT A C_FILE SYMBOL */
  1476.     if (name_length <= SYMNMLEN) {
  1477.       /* This name will fit into the symbol neatly */
  1478.       strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
  1479.     }
  1480.     else {
  1481.       native->u.syment._n._n_n._n_offset =  string_size + 4;
  1482.       native->u.syment._n._n_n._n_zeroes = 0;
  1483.       string_size += name_length + 1;
  1484.     }
  1485.       }
  1486. }
  1487.  
  1488.  
  1489.  
  1490. static unsigned int 
  1491. DEFUN(coff_write_symbol,(abfd, symbol, native, written),
  1492. bfd *abfd AND
  1493. asymbol *symbol AND
  1494. combined_entry_type *native AND
  1495. unsigned int written)
  1496. {
  1497.   unsigned int    numaux = native->u.syment.n_numaux;
  1498.   int             type = native->u.syment.n_type;
  1499.   int             class =  native->u.syment.n_sclass;
  1500.   SYMENT buf;
  1501.   unsigned int j;
  1502.  
  1503.   coff_fix_symbol_name(abfd, symbol, native);
  1504.   coff_swap_sym_out(abfd, &native->u.syment, &buf);
  1505.   bfd_write((PTR)& buf, 1, SYMESZ, abfd);
  1506.   for (j = 0; j != native->u.syment.n_numaux;  j++) 
  1507.       {
  1508.     AUXENT buf1;
  1509.     coff_swap_aux_out(abfd,
  1510.              &( (native + j + 1)->u.auxent), type, class, &buf1);
  1511.     bfd_write((PTR) (&buf1), 1, AUXESZ, abfd);
  1512.       }
  1513.   /*
  1514.     Reuse somewhere in the symbol to keep the index
  1515.     */
  1516.   set_index(symbol, written);
  1517.   return   written + 1 + numaux;
  1518. }
  1519.  
  1520.  
  1521. static unsigned int
  1522. DEFUN(coff_write_alien_symbol,(abfd, symbol, written),
  1523.       bfd *abfd AND
  1524.       asymbol *symbol AND
  1525.       unsigned int written)
  1526. {
  1527.   /*
  1528.     This symbol has been created by the loader, or come from a non
  1529.     coff format. It  has no native element to inherit, make our
  1530.     own
  1531.     */
  1532.  combined_entry_type *native;
  1533.  combined_entry_type dummy;
  1534.   native = &dummy;
  1535.   native->u.syment.n_type =  T_NULL;
  1536. #ifdef I960
  1537.   native->u.syment.n_flags =  0;
  1538. #endif
  1539.   if (symbol->flags & BSF_ABSOLUTE) {
  1540.     native->u.syment.n_scnum  =  N_ABS;
  1541.     native->u.syment.n_value =  symbol->value;
  1542.   }
  1543.   else if (symbol->flags & (BSF_UNDEFINED | BSF_FORT_COMM)) {
  1544.     native->u.syment.n_scnum =  N_UNDEF;
  1545.     native->u.syment.n_value =  symbol->value;
  1546.   }
  1547.   else if (symbol->flags & BSF_DEBUGGING) {
  1548.     /*
  1549.       remove name so it doesn't take up any space
  1550.       */
  1551.     symbol->name = "";
  1552.   }
  1553.   else {
  1554.     native->u.syment.n_scnum  =   symbol->section->output_section->index +
  1555.       1;
  1556.     native->u.syment.n_value =   symbol->value +
  1557.       symbol->section->output_section->vma +
  1558.     symbol->section->output_offset;
  1559. #ifdef I960
  1560.     /* Copy the any flags from the the file hdr into the symbol  */
  1561.       {
  1562.     coff_symbol_type *c = coff_symbol_from(abfd, symbol);
  1563.     if (c != (coff_symbol_type *)NULL) {
  1564.       native->u.syment.n_flags =   c->symbol.the_bfd->flags;
  1565.     }
  1566.       }
  1567. #endif
  1568.   }
  1569.   
  1570. #ifdef HASPAD1
  1571.   native->u.syment.pad1[0] = 0;
  1572.   native->u.syment.pad1[0] = 0;
  1573. #endif
  1574.   
  1575.   native->u.syment.n_type =  0;
  1576.   if (symbol->flags & BSF_LOCAL)
  1577.     native->u.syment.n_sclass =  C_STAT;
  1578.   else 
  1579.     native->u.syment.n_sclass =  C_EXT;
  1580.   native->u.syment.n_numaux =  0;
  1581.  
  1582.   return   coff_write_symbol(abfd, symbol, native, written);
  1583. }
  1584.  
  1585. static unsigned int 
  1586. DEFUN(coff_write_native_symbol,(abfd, symbol,   written),
  1587. bfd *abfd AND
  1588. coff_symbol_type *symbol AND
  1589. unsigned int written)
  1590. {
  1591.   /*
  1592.     Does this symbol have an ascociated line number - if so then
  1593.     make it remember this symbol index. Also tag the auxent of
  1594.     this symbol to point to the right place in the lineno table
  1595.     */
  1596.   combined_entry_type *native = symbol->native;
  1597.  
  1598.   alent          *lineno = symbol->lineno;
  1599.  
  1600.   if (lineno) {
  1601.     unsigned int    count = 0;
  1602.     lineno[count].u.offset = written;
  1603.     if (native->u.syment.n_numaux) {
  1604.       union internal_auxent  *a = &((native+1)->u.auxent);
  1605.             
  1606.       a->x_sym.x_fcnary.x_fcn.x_lnnoptr =  
  1607.     symbol->symbol.section->output_section->moving_line_filepos;
  1608.     }
  1609.     /*
  1610.       And count and relocate all other linenumbers
  1611.       */
  1612.     count++;
  1613.     while (lineno[count].line_number) {
  1614.       lineno[count].u.offset +=
  1615.     symbol->symbol.section->output_section->vma +
  1616.       symbol->symbol.section->output_offset;
  1617.       count++;
  1618.     }
  1619.     symbol->symbol.section->output_section->moving_line_filepos +=
  1620.       count * LINESZ;
  1621.           
  1622.   }
  1623.   return coff_write_symbol(abfd, &( symbol->symbol), native,written);
  1624. }
  1625.  
  1626. static void 
  1627. DEFUN(coff_write_symbols,(abfd),
  1628.       bfd            *abfd)
  1629. {
  1630.   unsigned int    i;
  1631.   unsigned int    limit = bfd_get_symcount(abfd);
  1632.   unsigned int    written = 0;
  1633.  
  1634.   asymbol       **p;
  1635.  
  1636.   string_size = 0;
  1637.     
  1638.     
  1639.   /* Seek to the right place */
  1640.   bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
  1641.     
  1642.   /* Output all the symbols we have */
  1643.     
  1644.   written = 0;
  1645.   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 
  1646.       {
  1647.     asymbol        *symbol = *p;
  1648.     coff_symbol_type *c_symbol = coff_symbol_from(abfd, symbol);
  1649.       
  1650.  
  1651.  
  1652.     if (c_symbol == (coff_symbol_type *) NULL ||
  1653.         c_symbol->native == (combined_entry_type *)NULL)
  1654.         {
  1655.           written = coff_write_alien_symbol(abfd, symbol, written);
  1656.         }
  1657.     else
  1658.         {
  1659.           written = coff_write_native_symbol(abfd, c_symbol, written);
  1660.         }
  1661.  
  1662.       }
  1663.  
  1664.   bfd_get_symcount(abfd) = written;
  1665.  
  1666.   /* Now write out strings */
  1667.     
  1668.   if (string_size != 0) 
  1669.    {
  1670.      unsigned int    size = string_size + 4;
  1671.      size =  size;
  1672.      bfd_write((PTR) &size, 1, sizeof(size), abfd);
  1673.      for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 
  1674.      {
  1675.        asymbol        *q = *p;
  1676.        size_t          name_length = strlen(q->name);
  1677.        int maxlen;
  1678.        coff_symbol_type*       c_symbol = coff_symbol_from(abfd, q);
  1679.        maxlen = ((c_symbol != NULL && c_symbol->native != NULL) && (c_symbol->native->u.syment.n_sclass == C_FILE)) ?
  1680.          FILNMLEN : SYMNMLEN;
  1681.     
  1682.        if (name_length > maxlen) {
  1683.          bfd_write((PTR) (q->name), 1, name_length + 1, abfd);
  1684.        }
  1685.      }
  1686.    }
  1687.   else {
  1688.     /* We would normally not write anything here, but we'll write
  1689.        out 4 so that any stupid coff reader which tries to read
  1690.        the string table even when there isn't one won't croak.
  1691.        */
  1692.       
  1693.     uint32e_type size = 4;
  1694.     size =  size;
  1695.     bfd_write((PTR)&size, 1, sizeof(size), abfd);
  1696.       
  1697.   }
  1698. }
  1699. #endif /* NO_COFF_SYMBOLS */
  1700.  
  1701. /*doc*
  1702. @subsubsection Writing Relocations
  1703. To write a relocations, all the back end does is step though the
  1704. canonical relocation table, and create an @code{internal_reloc}. The
  1705. symbol index to use is removed from the @code{offset} field in the
  1706. symbol table supplied, the address comes directly from the sum of the
  1707. section base address and the relocation offset and the type is dug
  1708. directly from the howto field.
  1709.  
  1710. Then the @code{internal_reloc} is swapped into the shape of an
  1711. @code{external_reloc} and written out to disk.
  1712. */
  1713.  
  1714. static void 
  1715. DEFUN(coff_write_relocs,(abfd),
  1716.       bfd            *abfd)
  1717. {
  1718.   asection       *s;
  1719.   for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
  1720.     unsigned int    i;
  1721.     struct external_reloc dst;
  1722.       
  1723.     arelent       **p = s->orelocation;
  1724.     bfd_seek(abfd, s->rel_filepos, SEEK_SET);
  1725.     for (i = 0; i < s->reloc_count; i++) {
  1726.       struct internal_reloc    n;
  1727.       arelent        *q = p[i];
  1728.       memset((PTR)&n, 0, sizeof(n));
  1729.       n.r_vaddr = q->address + s->vma;
  1730.       if (q->sym_ptr_ptr) {
  1731.     n.r_symndx = get_index((*(q->sym_ptr_ptr)));
  1732.       }
  1733. #ifdef SELECT_RELOC
  1734.       /* Work out reloc type from what is required */
  1735.       SELECT_RELOC(n.r_type, q->howto);
  1736. #else
  1737.       n.r_type = q->howto->type;
  1738. #endif
  1739.       bfd_swap_reloc_out(abfd, &n, &dst);
  1740.       bfd_write((PTR) &n, 1, RELSZ, abfd);
  1741.     }
  1742.   }
  1743. }
  1744.  
  1745. #ifndef NO_COFF_LINENOS
  1746.  
  1747. static void 
  1748. DEFUN(coff_write_linenumbers,(abfd),
  1749.       bfd            *abfd)
  1750. {
  1751.   asection       *s;
  1752.   for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
  1753.     if (s->lineno_count) {
  1754.       asymbol       **q = abfd->outsymbols;
  1755.       bfd_seek(abfd, s->line_filepos, SEEK_SET);
  1756.       /* Find all the linenumbers in this section */
  1757.       while (*q) {
  1758.     asymbol        *p = *q;
  1759.     alent          *l = BFD_SEND(p->the_bfd, _get_lineno, (p->the_bfd, p));
  1760.     if (l) {
  1761.       /* Found a linenumber entry, output */
  1762.       struct internal_lineno  out;
  1763.       LINENO buff;
  1764.       memset( (PTR)&out, 0, sizeof(out));
  1765.       out.l_lnno = 0;
  1766.       out.l_addr.l_symndx = l->u.offset;
  1767.       coff_swap_lineno_out(abfd, &out, &buff);
  1768.       bfd_write((PTR) &buff, 1, LINESZ, abfd);
  1769.       l++;
  1770.       while (l->line_number) {
  1771.         out.l_lnno = l->line_number;
  1772.         out.l_addr.l_symndx = l->u.offset;
  1773.         coff_swap_lineno_out(abfd, &out, &buff);
  1774.         bfd_write((PTR) &buff, 1, LINESZ, abfd);
  1775.         l++;
  1776.       }
  1777.     }
  1778.     q++;
  1779.       }
  1780.     }
  1781.   }
  1782. }
  1783.  
  1784. static alent   *
  1785. DEFUN(coff_get_lineno,(ignore_abfd, symbol),
  1786.       bfd            *ignore_abfd AND
  1787.       asymbol        *symbol)
  1788. {
  1789.   return coffsymbol(symbol)->lineno;
  1790. }
  1791.  
  1792. #endif /* NO_COFF_LINENOS */
  1793.  
  1794. static asymbol *
  1795. coff_make_empty_symbol(abfd)
  1796. bfd            *abfd;
  1797. {
  1798.   coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
  1799.   if (new == NULL) {
  1800.     bfd_error = no_memory;
  1801.     return (NULL);
  1802.   }                /* on error */
  1803.   new->native = 0;
  1804.   new->lineno = (alent *) NULL;
  1805.   new->symbol.the_bfd = abfd;
  1806.   return &new->symbol;
  1807. }
  1808.  
  1809. #ifndef NO_COFF_SYMBOLS
  1810.  
  1811. static void 
  1812. DEFUN(coff_print_symbol,(ignore_abfd, filep, symbol, how),
  1813.       bfd            *ignore_abfd AND
  1814.       PTR           filep AND
  1815.       asymbol        *symbol AND
  1816.       bfd_print_symbol_enum_type how)
  1817. {
  1818.   FILE *file = (FILE *)filep;
  1819.   switch (how) {
  1820.   case bfd_print_symbol_name_enum:
  1821.     fprintf(file, "%s", symbol->name);
  1822.     break;
  1823.   case bfd_print_symbol_type_enum:
  1824.     fprintf(file, "coff %lx %lx", (unsigned long) coffsymbol(symbol)->native,
  1825.         (unsigned long) coffsymbol(symbol)->lineno);
  1826.     break;
  1827.   case bfd_print_symbol_all_enum:
  1828.       {
  1829.     CONST char           *section_name = symbol->section == (asection *) NULL ?
  1830.       "*abs" : symbol->section->name;
  1831.     bfd_print_symbol_vandf((PTR) file, symbol);
  1832.       
  1833.     fprintf(file, " %-5s %s %s %s",
  1834.         section_name,
  1835.         coffsymbol(symbol)->native ? "n" : "g",
  1836.         coffsymbol(symbol)->lineno ? "l" : " ",
  1837.         symbol->name);
  1838.       }
  1839.       
  1840.       
  1841.     break;
  1842.   }
  1843. }
  1844.  
  1845. #endif /* NO_COFF_SYMBOLS */
  1846.  
  1847. /* Set flags and magic number of a coff file from architecture and machine
  1848.    type.  Result is true if we can represent the arch&type, false if not.  */
  1849.  
  1850. static          boolean
  1851. DEFUN(coff_set_flags,(abfd, magicp, flagsp),
  1852.       bfd            *abfd AND
  1853.       unsigned       *magicp AND
  1854.       unsigned short *flagsp)
  1855. {
  1856.     
  1857.   switch (abfd->obj_arch) {
  1858.       
  1859. #ifdef I960ROMAGIC
  1860.       
  1861.   case bfd_arch_i960:
  1862.       
  1863.       {
  1864.     unsigned        flags;
  1865.     *magicp = I960ROMAGIC;
  1866.     /*
  1867.       ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
  1868.       I960RWMAGIC);   FIXME???
  1869.       */
  1870.     switch (abfd->obj_machine) {
  1871.     case bfd_mach_i960_core:
  1872.       flags = F_I960CORE;
  1873.       break;
  1874.     case bfd_mach_i960_kb_sb:
  1875.       flags = F_I960KB;
  1876.       break;
  1877.     case bfd_mach_i960_mc:
  1878.       flags = F_I960MC;
  1879.       break;
  1880.     case bfd_mach_i960_xa:
  1881.       flags = F_I960XA;
  1882.       break;
  1883.     case bfd_mach_i960_ca:
  1884.       flags = F_I960CA;
  1885.       break;
  1886.     case bfd_mach_i960_ka_sa:
  1887.       flags = F_I960KA;
  1888.       break;
  1889.     default:
  1890.       return false;
  1891.     }
  1892.     *flagsp = flags;
  1893.     return true;
  1894.       }
  1895.     break;
  1896. #endif
  1897. #ifdef MIPS
  1898.   case bfd_arch_mips:
  1899.     *magicp = MIPS_MAGIC_2;
  1900.     return true;
  1901.     break;
  1902. #endif
  1903. #ifdef I386MAGIC
  1904.   case bfd_arch_i386:
  1905.     *magicp = I386MAGIC;
  1906.     return true;
  1907. #endif
  1908. #ifdef MC68MAGIC
  1909.   case bfd_arch_m68k:
  1910.     *magicp = MC68MAGIC;
  1911.     return true;
  1912. #endif
  1913.     
  1914. #ifdef MC88MAGIC
  1915.   case bfd_arch_m88k:
  1916.     *magicp = MC88OMAGIC;
  1917.     return true;
  1918.     break;
  1919. #endif
  1920.  
  1921. #ifdef A29K_MAGIC_BIG
  1922.   case bfd_arch_a29k:
  1923.     if (abfd->xvec->byteorder_big_p)
  1924.         *magicp = A29K_MAGIC_BIG;
  1925.     else
  1926.         *magicp = A29K_MAGIC_LITTLE;
  1927.     return true;
  1928.     break;
  1929. #endif
  1930.     
  1931.   default:            /* Unknown architecture */
  1932.     /* return false;  -- fall through to "return false" below, to avoid
  1933.              "statement never reached" errors on the one below. */    
  1934.     break;
  1935.   }
  1936.     
  1937.   return false;
  1938. }
  1939.  
  1940.  
  1941. static          boolean
  1942. DEFUN(coff_set_arch_mach,(abfd, arch, machine),
  1943.       bfd            *abfd AND
  1944.       enum bfd_architecture arch AND
  1945.       unsigned long   machine)
  1946. {
  1947.     unsigned        dummy1;
  1948.     unsigned     short dummy2;
  1949.     abfd->obj_arch = arch;
  1950.     abfd->obj_machine = machine;
  1951.     if (arch != bfd_arch_unknown &&
  1952.     coff_set_flags(abfd, &dummy1, &dummy2) != true)
  1953.       return false;        /* We can't represent this type */
  1954.     return true;        /* We're easy ... */
  1955.   }
  1956.  
  1957.  
  1958. /* Calculate the file position for each section. */
  1959.  
  1960. static void 
  1961. DEFUN(coff_compute_section_file_positions,(abfd),
  1962.       bfd            *abfd)
  1963. {
  1964.   asection       *current;
  1965.   file_ptr        sofar = FILHSZ;
  1966.   if (bfd_get_start_address(abfd)) {
  1967.     /*
  1968.       A start address may have been added to the original file. In this
  1969.       case it will need an optional header to record it.
  1970.       */
  1971.     abfd->flags |= EXEC_P;
  1972.   }
  1973.   if (abfd->flags & EXEC_P)
  1974.     sofar += AOUTSZ;
  1975.   
  1976.   
  1977.   sofar += abfd->section_count * SCNHSZ;
  1978.   for (current = abfd->sections;    
  1979.        current != (asection *)NULL;
  1980.        current = current->next) {
  1981.     /* Only deal with sections which have contents */
  1982.     if (!(current->flags & SEC_HAS_CONTENTS))
  1983.       continue;
  1984.     
  1985.     /* Align the sections in the file to the same boundary on 
  1986.        which they are aligned in virtual memory.  I960 doesn't
  1987.        do this (FIXME) so we can stay in sync with Intel.  960
  1988.        doesn't yet page from files... */
  1989. #ifndef I960
  1990.     sofar = ALIGN(sofar, 1 << current->alignment_power);
  1991. #endif
  1992.     /* FIXME, in demand paged files, the low order bits of the file
  1993.        offset must match the low order bits of the virtual address.
  1994.        "Low order" is apparently implementation defined.  Add code
  1995.        here to round sofar up to match the virtual address.  */
  1996.     
  1997.     current->filepos = sofar;
  1998.     sofar += current->size;
  1999.   }
  2000.   obj_relocbase(abfd) = sofar;
  2001. }
  2002.  
  2003.  
  2004.  
  2005.  
  2006. /* SUPPRESS 558 */
  2007. /* SUPPRESS 529 */
  2008. static          boolean
  2009. DEFUN(coff_write_object_contents,(abfd),
  2010.       bfd            *abfd)
  2011.   {
  2012.     asection       *current;
  2013.     boolean         hasrelocs = false;
  2014.     boolean         haslinno = false;
  2015.     file_ptr        reloc_base;
  2016.     file_ptr        lineno_base;
  2017.     file_ptr        sym_base;
  2018.     file_ptr        scn_base;
  2019.     file_ptr        data_base;
  2020.     unsigned long   reloc_size = 0;
  2021.     unsigned long   lnno_size = 0;
  2022.     asection       *text_sec = NULL;
  2023.     asection       *data_sec = NULL;
  2024.     asection       *bss_sec = NULL;
  2025.     
  2026.     struct internal_filehdr internal_f;
  2027.     struct internal_aouthdr internal_a;
  2028.     
  2029.     
  2030.     bfd_error = system_call_error;
  2031.     
  2032.     
  2033.     if(abfd->output_has_begun == false) {
  2034.       coff_compute_section_file_positions(abfd);
  2035.     }
  2036.     
  2037.     if (abfd->sections != (asection *)NULL) {
  2038.       scn_base = abfd->sections->filepos;
  2039.   }
  2040.   else {
  2041.     scn_base = 0;
  2042.   }
  2043.   if (bfd_seek(abfd, scn_base, SEEK_SET) != 0)
  2044.     return false;
  2045.   reloc_base = obj_relocbase(abfd);
  2046.     
  2047.   /* Make a pass through the symbol table to count line number entries and
  2048.      put them into the correct asections */
  2049.     
  2050. #ifndef NO_COFF_LINENOS
  2051.   coff_count_linenumbers(abfd);
  2052. #endif
  2053.   data_base = scn_base;
  2054.     
  2055.   /* Work out the size of the reloc and linno areas */
  2056.     
  2057.   for (current = abfd->sections; current != NULL; current = current->next) {
  2058.     reloc_size += current->reloc_count * RELSZ;
  2059. #ifndef NO_COFF_LINENOS
  2060.     lnno_size += current->lineno_count * LINESZ;
  2061. #endif
  2062.     data_base += SCNHSZ;
  2063.   }
  2064.     
  2065.   lineno_base = reloc_base + reloc_size;
  2066.   sym_base = lineno_base + lnno_size;
  2067.     
  2068.   /* Indicate in each section->line_filepos its actual file address */
  2069.   for (current = abfd->sections; current != NULL; current = current->next) {
  2070.     if (current->lineno_count) {
  2071.       current->line_filepos = lineno_base;
  2072.       current->moving_line_filepos = lineno_base;
  2073. #ifndef NO_COFF_LINENOS
  2074.       lineno_base += current->lineno_count * LINESZ;
  2075. #endif
  2076.     }
  2077.     else {
  2078.       current->line_filepos = 0;
  2079.     }
  2080.     if (current->reloc_count) {
  2081.       current->rel_filepos = reloc_base;
  2082.       reloc_base += current->reloc_count * sizeof(struct internal_reloc);
  2083.     }
  2084.     else {
  2085.       current->rel_filepos = 0;
  2086.     }
  2087.   }
  2088.     
  2089.   /* Write section headers to the file.  */
  2090.     
  2091.   bfd_seek(abfd,
  2092.        (file_ptr) ((abfd->flags & EXEC_P) ?
  2093.                (FILHSZ + AOUTSZ) : FILHSZ),
  2094.        SEEK_SET);
  2095.     
  2096.     {
  2097. #if 0
  2098.       unsigned int    pad = abfd->flags & D_PAGED ? data_base : 0;
  2099. #endif
  2100.       unsigned int    pad = 0;
  2101.     
  2102.       for (current = abfd->sections; current != NULL; current = current->next) {
  2103.     struct internal_scnhdr section;
  2104.     strncpy(&(section.s_name[0]), current->name, 8);
  2105.     section.s_vaddr = current->vma + pad;
  2106.     section.s_paddr = current->vma + pad;
  2107.     section.s_size = current->size - pad;
  2108.     /*
  2109.       If this section has no size or is unloadable then the scnptr
  2110.       will be 0 too
  2111.       */
  2112.     if (current->size - pad == 0 ||
  2113.         (current->flags & SEC_LOAD) == 0) {
  2114.       section.s_scnptr = 0;
  2115.         
  2116.     }
  2117.     else {
  2118.       section.s_scnptr = current->filepos;
  2119.     }
  2120.     section.s_relptr = current->rel_filepos;
  2121.     section.s_lnnoptr = current->line_filepos;
  2122.     section.s_nreloc = current->reloc_count;
  2123.     section.s_nlnno = current->lineno_count;
  2124.     if (current->reloc_count != 0)
  2125.       hasrelocs = true;
  2126.     if (current->lineno_count != 0)
  2127.       haslinno = true;
  2128.       
  2129.     section.s_flags = sec_to_styp_flags(current->name,current->flags);
  2130.  
  2131.     if (!strcmp(current->name, _TEXT)) {
  2132.       text_sec = current;
  2133.     } else if (!strcmp(current->name, _DATA)) {
  2134.       data_sec = current;
  2135.     } else if (!strcmp(current->name, _BSS)) {
  2136.       bss_sec = current;
  2137.     } 
  2138.       
  2139. #ifdef I960
  2140.     section.s_align = (current->alignment_power
  2141.                ? 1 << current->alignment_power
  2142.                : 0);
  2143.  
  2144. #endif
  2145.       {
  2146.         SCNHDR          buff;
  2147.  
  2148.         swap_scnhdr_out(abfd, §ion, &buff);
  2149.         bfd_write((PTR) (&buff), 1, SCNHSZ, abfd);
  2150.  
  2151.       }
  2152.     pad = 0;
  2153.       }
  2154.     }
  2155.  
  2156.   /* OK, now set up the filehdr... */
  2157.   internal_f.f_nscns = abfd->section_count;
  2158.   /*
  2159.     We will NOT put a fucking timestamp in the header here. Every time you
  2160.     put it back, I will come in and take it out again. I'm sorry. This
  2161.     field does not belong here.  We fill it with a 0 so it compares the
  2162.     same but is not a reasonable time. -- gnu@cygnus.com
  2163.     */
  2164.   /*
  2165.     Well, I like it, so I'm conditionally compiling it in.
  2166.     steve@cygnus.com
  2167.     */
  2168. #ifdef COFF_TIMESTAMP
  2169.   internal_f.f_timdat = time(0);
  2170. #else
  2171.   internal_f.f_timdat = 0;
  2172. #endif
  2173.  
  2174.   if (bfd_get_symcount(abfd) != 0)
  2175.     internal_f.f_symptr = sym_base;
  2176.   else
  2177.     internal_f.f_symptr = 0;
  2178.  
  2179.   internal_f.f_flags = 0;
  2180.  
  2181.   if (abfd->flags & EXEC_P)
  2182.     internal_f.f_opthdr = AOUTSZ;
  2183.   else
  2184.     internal_f.f_opthdr = 0;
  2185.  
  2186.   if (!hasrelocs)
  2187.     internal_f.f_flags |= F_RELFLG;
  2188.   if (!haslinno)
  2189.     internal_f.f_flags |= F_LNNO;
  2190.   if (0 == bfd_get_symcount(abfd))
  2191.     internal_f.f_flags |= F_LSYMS;
  2192.   if (abfd->flags & EXEC_P)
  2193.     internal_f.f_flags |= F_EXEC;
  2194. #if M88
  2195.   internal_f.f_flags |= F_AR32W;
  2196. #else
  2197.   if (!abfd->xvec->byteorder_big_p)
  2198.     internal_f.f_flags |= F_AR32WR;
  2199. #endif
  2200.   /*
  2201.     FIXME, should do something about the other byte orders and
  2202.     architectures.
  2203.     */
  2204.  
  2205.   /* Set up architecture-dependent stuff */
  2206.  
  2207.     { unsigned int   magic = 0;
  2208.       unsigned short    flags = 0;
  2209.       coff_set_flags(abfd, &magic, &flags);
  2210.       internal_f.f_magic = magic;
  2211.       internal_f.f_flags |= flags;
  2212.       /* ...and the "opt"hdr... */
  2213.  
  2214. #ifdef A29K 
  2215. # ifdef ULTRA3    /* NYU's machine */
  2216.     /* FIXME: This is a bogus check.  I really want to see if there
  2217.      * is a .shbss or a .shdata section, if so then set the magic
  2218.       * number to indicate a shared data executable.
  2219.      */ 
  2220.       if (internal_f.f_nscns >= 7)
  2221.           internal_a.magic = SHMAGIC;     /* Shared magic */
  2222.       else
  2223. # endif /* ULTRA3 */
  2224.           internal_a.magic = NMAGIC;     /* Assume separate i/d */
  2225. #define __A_MAGIC_SET__
  2226. #endif    /* A29K */
  2227. #ifdef I960
  2228.       internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC); 
  2229. #define __A_MAGIC_SET__
  2230. #endif     /* I960 */
  2231. #if M88
  2232. #define __A_MAGIC_SET__
  2233.       internal_a.magic = PAGEMAGICBCS;
  2234. #endif    /* M88 */
  2235.  
  2236. #if M68 || I386 || MIPS
  2237. #define __A_MAGIC_SET__
  2238.      /* Never was anything here for the 68k */ 
  2239. #endif    /* M88 */
  2240.  
  2241. #ifndef __A_MAGIC_SET__
  2242. # include "Your aouthdr magic number is not being set!"
  2243. #else
  2244. # undef __A_MAGIC_SET__
  2245. #endif
  2246.     }
  2247.   /* Now should write relocs, strings, syms */
  2248.   obj_sym_filepos(abfd) = sym_base;
  2249.  
  2250. #ifndef NO_COFF_SYMBOLS
  2251.   if (bfd_get_symcount(abfd) != 0) {
  2252.     coff_renumber_symbols(abfd);
  2253.     coff_mangle_symbols(abfd);
  2254.     coff_write_symbols(abfd);
  2255.     coff_write_linenumbers(abfd);
  2256.     coff_write_relocs(abfd);
  2257.   }
  2258. #endif /* NO_COFF_SYMBOLS */
  2259.   if (text_sec) {
  2260.     internal_a.tsize = text_sec->size;
  2261.     internal_a.text_start =text_sec->size ? text_sec->vma : 0;
  2262.   }
  2263.   if (data_sec) {
  2264.     internal_a.dsize = data_sec->size;
  2265.     internal_a.data_start = data_sec->size ? data_sec->vma      : 0;
  2266.   }
  2267.   if (bss_sec) {
  2268.     internal_a.bsize =  bss_sec->size;
  2269.   }
  2270.  
  2271.   internal_a.entry = bfd_get_start_address(abfd);
  2272.   internal_f.f_nsyms =  bfd_get_symcount(abfd);
  2273.  
  2274.   /* now write them */
  2275.   if (bfd_seek(abfd, 0L, SEEK_SET) != 0)
  2276.     return false;
  2277.     {
  2278.       FILHDR buff;
  2279.       bfd_swap_filehdr_out(abfd, &internal_f, &buff);
  2280.       bfd_write((PTR) &buff, 1, FILHSZ, abfd);
  2281.     }
  2282.   if (abfd->flags & EXEC_P) {
  2283.     AOUTHDR buff;
  2284.     bfd_swap_aouthdr_out(abfd, &internal_a, &buff);
  2285.     bfd_write((PTR) &buff, 1, AOUTSZ, abfd);
  2286.   }
  2287.   return true;
  2288. }
  2289.  
  2290. #ifndef NO_COFF_SYMBOLS
  2291.  
  2292. /*
  2293. this function transforms the offsets into the symbol table into
  2294. pointers to syments.
  2295. */
  2296.  
  2297.  
  2298. static void
  2299. DEFUN(coff_pointerize_aux,(abfd, table_base, type, class, auxent),
  2300. bfd *abfd AND
  2301. combined_entry_type *table_base AND
  2302. int type AND
  2303. int class AND
  2304. combined_entry_type *auxent)
  2305. {
  2306.   /* Don't bother if this is a file or a section */
  2307.   if (class == C_STAT && type == T_NULL) return;
  2308.   if (class == C_FILE) return;
  2309.  
  2310.   /* Otherwise patch up */
  2311.   if (ISFCN(type) || ISTAG(class) || class == C_BLOCK) {
  2312.     auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = table_base +
  2313.       auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
  2314.     auxent->fix_end = 1;
  2315.   }
  2316.   if (auxent->u.auxent.x_sym.x_tagndx.l != 0) {
  2317.     auxent->u.auxent.x_sym.x_tagndx.p = table_base +  auxent->u.auxent.x_sym.x_tagndx.l;
  2318.     auxent->fix_tag = 1;
  2319.   }
  2320. }
  2321.  
  2322. #endif /* NO_COFF_SYMBOLS */
  2323.  
  2324. static          boolean
  2325. DEFUN(coff_set_section_contents,(abfd, section, location, offset, count),
  2326.       bfd            *abfd AND
  2327.       sec_ptr         section AND
  2328.       PTR             location AND
  2329.       file_ptr        offset AND
  2330.       bfd_size_type   count)
  2331. {
  2332.     if (abfd->output_has_begun == false)    /* set by bfd.c handler */
  2333.     coff_compute_section_file_positions(abfd);
  2334.  
  2335.     bfd_seek(abfd, (file_ptr) (section->filepos + offset), SEEK_SET);
  2336.  
  2337.     if (count != 0) {
  2338.     return (bfd_write(location, 1, count, abfd) == count) ? true : false;
  2339.     }
  2340.     return true;
  2341. }
  2342. #if 0
  2343. static          boolean
  2344. coff_close_and_cleanup(abfd)
  2345.     bfd            *abfd;
  2346. {
  2347.   if (!bfd_read_p(abfd))
  2348.     switch (abfd->format) {
  2349.     case bfd_archive:
  2350.       if (!_bfd_write_archive_contents(abfd))
  2351.     return false;
  2352.       break;
  2353.     case bfd_object:
  2354.       if (!coff_write_object_contents(abfd))
  2355.     return false;
  2356.       break;
  2357.     default:
  2358.       bfd_error = invalid_operation;
  2359.       return false;
  2360.     }
  2361.  
  2362.   /* We depend on bfd_close to free all the memory on the obstack.  */
  2363.   /* FIXME if bfd_release is not using obstacks! */
  2364.   return true;
  2365. }
  2366.  
  2367. #endif
  2368. static PTR 
  2369. buy_and_read(abfd, where, seek_direction, size)
  2370.     bfd            *abfd;
  2371.     file_ptr        where;
  2372.     int             seek_direction;
  2373.     size_t          size;
  2374. {
  2375.     PTR             area = (PTR) bfd_alloc(abfd, size);
  2376.     if (!area) {
  2377.     bfd_error = no_memory;
  2378.     return (NULL);
  2379.     }
  2380.     bfd_seek(abfd, where, seek_direction);
  2381.     if (bfd_read(area, 1, size, abfd) != size) {
  2382.     bfd_error = system_call_error;
  2383.     return (NULL);
  2384.     }                /* on error */
  2385.     return (area);
  2386. }                /* buy_and_read() */
  2387.  
  2388.  
  2389. #ifndef NO_COFF_SYMBOLS
  2390.  
  2391. static char *
  2392. DEFUN(build_string_table,(abfd),
  2393. bfd *abfd)
  2394. {
  2395.   char string_table_size_buffer[4];
  2396.   unsigned int string_table_size;
  2397.   char *string_table;
  2398.   /*
  2399.     At this point we should be "seek"'d to the end of the
  2400.     symbols === the symbol table size.
  2401.     */
  2402.       
  2403.   if (bfd_read((char *) string_table_size_buffer,
  2404.            sizeof(string_table_size_buffer),
  2405.            1, abfd) != sizeof(string_table_size)) {
  2406.     bfd_error = system_call_error;
  2407.     return (NULL);
  2408.   }                /* on error */
  2409.       
  2410.   string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
  2411.       
  2412.   if ((string_table = (PTR) bfd_alloc(abfd, string_table_size -= 4)) == NULL) {
  2413.     bfd_error = no_memory;
  2414.     return (NULL);
  2415.   }                /* on mallocation error */
  2416.   if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size) {
  2417.     bfd_error = system_call_error;
  2418.     return (NULL);
  2419.   }            
  2420.   return string_table;
  2421. }
  2422.  
  2423. /*
  2424. read a symbol table into freshly mallocated memory, swap it, and knit the
  2425. symbol names into a normalized form. By normalized here I mean that all
  2426. symbols have an n_offset pointer that points to a NULL terminated string.
  2427. Oh, and the first symbol MUST be a C_FILE.  If there wasn't one there
  2428. before, put one there.
  2429. */
  2430.  
  2431. static combined_entry_type *
  2432. DEFUN(get_normalized_symtab,(abfd),
  2433. bfd            *abfd)
  2434. {
  2435.  
  2436.   combined_entry_type          *internal;
  2437.   combined_entry_type          *internal_ptr;
  2438.   combined_entry_type         *internal_end;
  2439.   SYMENT *raw;
  2440.   SYMENT *raw_src;
  2441.   SYMENT *raw_end;
  2442.   char           *string_table = NULL;
  2443.   unsigned long   size;
  2444.  
  2445.  
  2446.   unsigned int raw_size;
  2447.   if (obj_raw_syments(abfd) != (combined_entry_type *)NULL) {
  2448.     return obj_raw_syments(abfd);
  2449.   }
  2450.   if ((size = bfd_get_symcount(abfd) * sizeof(combined_entry_type)) == 0) {
  2451.     bfd_error = no_symbols;
  2452.     return (NULL);
  2453.   }
  2454.  
  2455.   internal = (combined_entry_type *)bfd_alloc(abfd, size);
  2456.   internal_end = internal + bfd_get_symcount(abfd);
  2457.  
  2458.   raw_size =      bfd_get_symcount(abfd) * SYMESZ;
  2459.   raw = (SYMENT *)bfd_alloc(abfd,raw_size);
  2460.  
  2461.   if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
  2462.       || bfd_read((PTR)raw, raw_size, 1, abfd) != raw_size) {
  2463.     bfd_error = system_call_error;
  2464.     return (NULL);
  2465.   }
  2466.   /* mark the end of the symbols */
  2467.   raw_end = raw + bfd_get_symcount(abfd);
  2468.   /*
  2469.     FIXME SOMEDAY.  A string table size of zero is very weird, but
  2470.     probably possible.  If one shows up, it will probably kill us.
  2471.     */
  2472.  
  2473.   /* Swap all the raw entries */
  2474.   for (raw_src = raw, internal_ptr = internal; raw_src < raw_end; raw_src++, internal_ptr++) {
  2475.     unsigned int i;
  2476.     coff_swap_sym_in(abfd, raw_src,&internal_ptr->u.syment);    
  2477.     internal_ptr->fix_tag = 0;
  2478.     internal_ptr->fix_end = 0;
  2479.  
  2480.     for (i = internal_ptr->u.syment.n_numaux; i; --i, raw_src++, internal_ptr++) {
  2481.       (internal_ptr+1)->fix_tag = 0;
  2482.       (internal_ptr+1)->fix_end = 0;
  2483.  
  2484.       coff_swap_aux_in(abfd, (AUXENT *)(raw_src +1), internal_ptr->u.syment.n_type,
  2485.                internal_ptr->u.syment.n_sclass, &     (internal_ptr+1)->u.auxent);
  2486.  
  2487.       coff_pointerize_aux(abfd, 
  2488.               internal,
  2489.               internal_ptr->u.syment.n_type,
  2490.               internal_ptr->u.syment.n_sclass,
  2491.               internal_ptr +1);
  2492.     }
  2493.   }
  2494.       
  2495.   /* Free all the raw stuff */
  2496.   bfd_release(abfd, raw_src);
  2497.  
  2498.   for (internal_ptr = internal; internal_ptr < internal_end;
  2499.        internal_ptr ++) 
  2500.       {
  2501.     if (internal_ptr->u.syment.n_sclass == C_FILE) {
  2502.       /* make a file symbol point to the name in the auxent, since
  2503.          the text ".file" is redundant */
  2504.       if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) {
  2505.         /* the filename is a long one, point into the string table
  2506.          */
  2507.         if (string_table == NULL) {
  2508.           string_table = build_string_table(abfd);
  2509.         }
  2510.  
  2511.         internal_ptr->u.syment._n._n_n._n_offset =
  2512.           (int) (string_table - 4 +
  2513.              (internal_ptr+1)->u.auxent.x_file.x_n.x_offset);
  2514.       }
  2515.       else {
  2516.         /* ordinary short filename, put into memory anyway */
  2517.         internal_ptr->u.syment._n._n_n._n_offset = (int)
  2518.           copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname, FILNMLEN);
  2519.         
  2520.       }
  2521.     }
  2522.     else {
  2523.       if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) {
  2524.         /*
  2525.           This is a "short" name.  Make it long.
  2526.           */
  2527.         unsigned long   i = 0;
  2528.         char           *newstring = NULL;
  2529.         /*
  2530.           find the length of this string without walking into memory
  2531.           that isn't ours.
  2532.           */
  2533.     
  2534.         for (i = 0; i < 8; ++i) {
  2535.           if (internal_ptr->u.syment._n._n_name[i] == '\0') {
  2536.         break;
  2537.           }            /* if end of string */
  2538.         }            /* possible lengths of this string. */
  2539.     
  2540.         if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
  2541.           bfd_error = no_memory;
  2542.           return (NULL);
  2543.         }            /* on error */
  2544.         bzero(newstring, i);
  2545.         strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1);
  2546.         internal_ptr->u.syment._n._n_n._n_offset =  (int) newstring;
  2547.         internal_ptr->u.syment._n._n_n._n_zeroes = 0;
  2548.     
  2549.       }
  2550.       else {
  2551.         /*  This is a long name already. Just point it at the string in memory.   */
  2552.         if (string_table == NULL) {
  2553.           string_table = build_string_table(abfd);
  2554.         }
  2555.         internal_ptr->u.syment._n._n_n._n_offset =
  2556.           (int) (string_table - 4 +  internal_ptr->u.syment._n._n_n._n_offset);
  2557.       }    
  2558.     }
  2559.     internal_ptr += internal_ptr->u.syment.n_numaux;
  2560.       }    
  2561.  
  2562.   obj_raw_syments(abfd) = internal;
  2563.   obj_string_table(abfd) = string_table;
  2564.     
  2565.   return (internal);
  2566. }                /* get_normalized_symtab() */
  2567.  
  2568. #endif /* NO_COFF_SYMBOLS */
  2569.  
  2570. static
  2571. struct sec *
  2572. DEFUN(section_from_bfd_index,(abfd, index),
  2573.       bfd            *abfd AND
  2574.       int             index)
  2575. {
  2576.   if (index > 0) {
  2577.     struct sec *answer = abfd->sections;
  2578.     while (--index) {
  2579.       answer = answer->next;
  2580.     }
  2581.     return answer;
  2582.   }
  2583.   return 0;
  2584. }
  2585.  
  2586. #ifndef NO_COFF_LINENOS
  2587.  
  2588. /*doc*
  2589. @subsubsection Reading Linenumbers
  2590. Createing the linenumber table is done by reading in the entire coff
  2591. linenumber table, and creating another table for internal use.
  2592.  
  2593. A coff line number table is structured so that each
  2594. function is marked as having a line number of 0. Each line within the
  2595. function is an offset from the first line in the function. The base of
  2596. the line number information for the table is stored in the symbol
  2597. associated with the function.
  2598.  
  2599. The information is copied from the external to the internal table, and
  2600. each symbol which marks a function is marked by pointing its...
  2601.  
  2602. **How does this work ?**
  2603.  
  2604. */
  2605.  
  2606. static boolean
  2607. coff_slurp_line_table(abfd, asect)
  2608. bfd            *abfd;
  2609. asection       *asect;
  2610.   {
  2611.     LINENO  *native_lineno;
  2612.     alent          *lineno_cache;
  2613.     
  2614.     BFD_ASSERT(asect->lineno == (alent *) NULL);
  2615.     
  2616.     native_lineno = (LINENO *) buy_and_read(abfd,
  2617.                         asect->line_filepos,
  2618.                         SEEK_SET,
  2619.                         (size_t) (LINESZ *
  2620.                               asect->lineno_count));
  2621.     lineno_cache =
  2622.       (alent *) bfd_alloc(abfd, (size_t) ((asect->lineno_count + 1) * sizeof(alent)));
  2623.     if (lineno_cache == NULL) {
  2624.       bfd_error = no_memory;
  2625.       return false;
  2626.     } else {    
  2627.       unsigned int    counter = 0;
  2628.       alent          *cache_ptr = lineno_cache;
  2629.       LINENO  *src = native_lineno;
  2630.       
  2631.       while (counter < asect->lineno_count) {
  2632.     struct internal_lineno dst;
  2633.     coff_swap_lineno_in(abfd, src, &dst);
  2634.     cache_ptr->line_number = dst.l_lnno;
  2635.     
  2636.     if (cache_ptr->line_number == 0) {
  2637.       coff_symbol_type *sym =
  2638.         (coff_symbol_type *) (dst.l_addr.l_symndx
  2639.                   + obj_symbol_slew(abfd)
  2640.                   + obj_raw_syments(abfd))->u.syment._n._n_n._n_zeroes;
  2641.       cache_ptr->u.sym = (asymbol *) sym;
  2642.       sym->lineno = cache_ptr;
  2643.     }
  2644.     else {
  2645.       cache_ptr->u.offset = dst.l_addr.l_paddr
  2646.         - bfd_section_vma(abfd, asect);
  2647.     }                /* If no linenumber expect a symbol index */
  2648.     
  2649.     cache_ptr++;
  2650.     src++;
  2651.     counter++;
  2652.       }
  2653.       cache_ptr->line_number = 0;
  2654.       
  2655.     }
  2656.     asect->lineno = lineno_cache;
  2657.     /* FIXME, free native_lineno here, or use alloca or something. */
  2658.     return true;
  2659.   }                /* coff_slurp_line_table() */
  2660.  
  2661. #endif /* NO_COFF_LINENOS */
  2662.  
  2663. #ifndef NO_COFF_LINENOS
  2664.  
  2665. static          boolean
  2666. DEFUN(coff_slurp_symbol_table,(abfd),
  2667.       bfd            *abfd)
  2668. {
  2669.   combined_entry_type         *native_symbols;
  2670.   coff_symbol_type *cached_area;
  2671.   unsigned int   *table_ptr;
  2672.     
  2673.   unsigned int    number_of_symbols = 0;
  2674.   if (obj_symbols(abfd))
  2675.     return true;
  2676.   bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
  2677.     
  2678.   /* Read in the symbol table */
  2679.   if ((native_symbols = get_normalized_symtab(abfd)) == NULL) {
  2680.     return (false);
  2681.   }                /* on error */
  2682.     
  2683.     
  2684.   /* Allocate enough room for all the symbols in cached form */
  2685.   cached_area =
  2686.     (coff_symbol_type *)
  2687.       bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(coff_symbol_type)));
  2688.     
  2689.   if (cached_area == NULL) {
  2690.     bfd_error = no_memory;
  2691.     return false;
  2692.   }                /* on error */
  2693.   table_ptr =
  2694.     (unsigned int *)
  2695.       bfd_alloc(abfd, (size_t) (bfd_get_symcount(abfd) * sizeof(unsigned int)));
  2696.     
  2697.   if (table_ptr == NULL) {
  2698.     bfd_error = no_memory;
  2699.     return false;
  2700.   } else {
  2701.     coff_symbol_type *dst = cached_area;
  2702.     unsigned int    last_native_index = bfd_get_symcount(abfd);
  2703.     unsigned int    this_index = 0;
  2704.     while (this_index < last_native_index) {
  2705.       combined_entry_type         *src = native_symbols + this_index;
  2706.       table_ptr[this_index] = number_of_symbols;
  2707.       dst->symbol.the_bfd = abfd;
  2708.     
  2709.       dst->symbol.name = (char *)(src->u.syment._n._n_n._n_offset);
  2710.       /*
  2711.     We use the native name field to point to the cached field
  2712.     */
  2713.       src->u.syment._n._n_n._n_zeroes = (int) dst;
  2714.       dst->symbol.section = section_from_bfd_index(abfd,
  2715.                            src->u.syment.n_scnum);
  2716.       switch (src->u.syment.n_sclass) {
  2717. #ifdef I960
  2718.       case C_LEAFEXT:
  2719. #if 0
  2720.     dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
  2721.     dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
  2722.     dst->symbol.flags |= BSF_NOT_AT_END;
  2723. #endif
  2724.     /* Fall through to next case */
  2725.       
  2726. #endif
  2727.       
  2728.       case C_EXT:
  2729.     if ((src->u.syment.n_scnum) == 0) {
  2730.       if ((src->u.syment.n_value) == 0) {
  2731.         dst->symbol.flags = BSF_UNDEFINED;
  2732.         dst->symbol.value= 0;
  2733.       }
  2734.       else {
  2735.         dst->symbol.flags = BSF_FORT_COMM;
  2736.         dst->symbol.value = (src->u.syment.n_value);
  2737.       }
  2738.     }
  2739.     else {
  2740.       /*
  2741.         Base the value as an index from the base of the
  2742.         section
  2743.         */
  2744.       if (dst->symbol.section == (asection *) NULL) {
  2745.         dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL | BSF_ABSOLUTE;
  2746.         dst->symbol.value = src->u.syment.n_value;
  2747.       }
  2748.       else {
  2749.         dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
  2750.         dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
  2751.       }
  2752.       if (ISFCN((src->u.syment.n_type))) {
  2753.         /*
  2754.           A function ext does not go at the end of a file
  2755.           */
  2756.         dst->symbol.flags |= BSF_NOT_AT_END;
  2757.       }
  2758.     }
  2759.       
  2760.     break;
  2761.       case C_STAT:        /* static             */
  2762. #ifdef I960
  2763.       case C_LEAFSTAT:        /* static leaf procedure        */
  2764. #endif
  2765.       case C_LABEL:        /* label             */
  2766.     dst->symbol.flags = BSF_LOCAL;
  2767.     /*
  2768.       Base the value as an index from the base of the section
  2769.       */
  2770.     dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
  2771.     break;
  2772.       
  2773.       case C_MOS:        /* member of structure     */
  2774.       case C_EOS:        /* end of structure         */
  2775. #ifdef NOTDEF    /* C_AUTOARG has the same value */
  2776. #ifdef C_GLBLREG
  2777.       case C_GLBLREG:        /* A29k-specific storage class */
  2778. #endif
  2779. #endif
  2780.       case C_REGPARM:        /* register parameter         */
  2781.       case C_REG:        /* register variable         */
  2782. #ifdef C_AUTOARG
  2783.       case C_AUTOARG:        /* 960-specific storage class */
  2784. #endif
  2785.       case C_TPDEF:        /* type definition         */
  2786.       
  2787.       case C_ARG:
  2788.       case C_AUTO:        /* automatic variable */
  2789.       case C_FIELD:        /* bit field */
  2790.       case C_ENTAG:        /* enumeration tag         */
  2791.       case C_MOE:        /* member of enumeration     */
  2792.       case C_MOU:        /* member of union         */
  2793.       case C_UNTAG:        /* union tag             */
  2794.       
  2795.     dst->symbol.flags = BSF_DEBUGGING;
  2796.     dst->symbol.value = (src->u.syment.n_value);
  2797.     break;
  2798.       
  2799.       case C_FILE:        /* file name             */
  2800.       case C_STRTAG:        /* structure tag         */
  2801.     dst->symbol.flags = BSF_DEBUGGING;
  2802.     dst->symbol.value = (src->u.syment.n_value);
  2803.       
  2804.     break;
  2805.       case C_BLOCK:        /* ".bb" or ".eb"         */
  2806.       case C_FCN:        /* ".bf" or ".ef"         */
  2807.       case C_EFCN:        /* physical end of function     */
  2808.     dst->symbol.flags = BSF_LOCAL;
  2809.     /*
  2810.       Base the value as an index from the base of the section
  2811.       */
  2812.     dst->symbol.value = (src->u.syment.n_value) - dst->symbol.section->vma;
  2813.       
  2814.     break;
  2815.       case C_NULL:
  2816.       case C_EXTDEF:        /* external definition         */
  2817.       case C_ULABEL:        /* undefined label         */
  2818.       case C_USTATIC:        /* undefined static         */
  2819.       case C_LINE:        /* line # reformatted as symbol table entry */
  2820.       case C_ALIAS:        /* duplicate tag         */
  2821.       case C_HIDDEN:        /* ext symbol in dmert public lib */
  2822.       
  2823.       default:
  2824.       
  2825.     fprintf(stderr,"Unrecognized storage class %d\n", 
  2826.                 src->u.syment.n_sclass);
  2827.     abort();
  2828.     dst->symbol.flags = BSF_DEBUGGING;
  2829.     dst->symbol.value = (src->u.syment.n_value);
  2830.       
  2831.     break;
  2832.       }
  2833.     
  2834.       BFD_ASSERT(dst->symbol.flags != 0);
  2835.     
  2836.       dst->native = src;
  2837.     
  2838.       dst->symbol.udata = 0;
  2839.       dst->lineno = (alent *) NULL;
  2840.       this_index += (src->u.syment.n_numaux) + 1;
  2841.       dst++;
  2842.       number_of_symbols++;
  2843.     }                /* walk the native symtab */
  2844.   }                /* bfdize the native symtab */
  2845.     
  2846.   obj_symbols(abfd) = cached_area;
  2847.   obj_raw_syments(abfd) = native_symbols;
  2848.     
  2849.   bfd_get_symcount(abfd) = number_of_symbols;
  2850.   obj_convert(abfd) = table_ptr;
  2851.   /* Slurp the line tables for each section too */
  2852.     {
  2853.       asection       *p;
  2854.       p = abfd->sections;
  2855.       while (p) {
  2856.     coff_slurp_line_table(abfd, p);
  2857.     p = p->next;
  2858.       }
  2859.     }
  2860.   return true;
  2861. }                /* coff_slurp_symbol_table() */
  2862.  
  2863. static unsigned int
  2864. coff_get_symtab_upper_bound(abfd)
  2865. bfd            *abfd;
  2866.   {
  2867.     if (!coff_slurp_symbol_table(abfd))
  2868.       return 0;
  2869.     
  2870.     return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
  2871.   }
  2872.  
  2873.  
  2874. static unsigned int
  2875. coff_get_symtab(abfd, alocation)
  2876. bfd            *abfd;
  2877. asymbol       **alocation;
  2878.   {
  2879.     unsigned int    counter = 0;
  2880.     coff_symbol_type *symbase;
  2881.     coff_symbol_type **location = (coff_symbol_type **) (alocation);
  2882.     if (!coff_slurp_symbol_table(abfd))
  2883.       return 0;
  2884.     
  2885.     for (symbase = obj_symbols(abfd); counter++ < bfd_get_symcount(abfd);)
  2886.       *(location++) = symbase++;
  2887.     *location++ = 0;
  2888.     return bfd_get_symcount(abfd);
  2889.   }
  2890.  
  2891. #endif /* NO_COFF_SYMBOLS */
  2892.  
  2893. static unsigned int
  2894. coff_get_reloc_upper_bound(abfd, asect)
  2895. bfd            *abfd;
  2896. sec_ptr         asect;
  2897.   {
  2898.     if (bfd_get_format(abfd) != bfd_object) {
  2899.       bfd_error = invalid_operation;
  2900.       return 0;
  2901.     }
  2902.     return (asect->reloc_count + 1) * sizeof(arelent *);
  2903.   }
  2904.  
  2905. /*doc*
  2906. @subsubsection Reading Relocations
  2907. Coff relocations are easily transformed into the internal bfd form
  2908. (@code{arelent}). 
  2909.  
  2910. Reading a coff relocation table is done in the following stages:
  2911. @itemize @bullet
  2912. @item 
  2913. The entire coff relocation table is read into memory.
  2914. @item
  2915. Each relocation is processed in turn, first it is swapped from the
  2916. external to the internal form.
  2917. @item
  2918. The symbol referenced in the relocation's symbol index is turned into
  2919. a pointer into the canonical symbol table. Note that this table is the
  2920. same as the one returned by a call to @code{bfd_canonicalize_symtab}.
  2921. The back end will call the routine and save the result if a
  2922. canonicalization hasn't been done.
  2923. @item
  2924. The reloc index is turned into a pointer to a howto structure, in a
  2925. back end specific way. For instance, the 386 and 960 use the
  2926. @code{r_type} to directly produce an index into a howto table vector;
  2927. the 88k subtracts a number from the @code{r_type} field and creates an
  2928. addend field.
  2929. @end itemize
  2930. */
  2931.  
  2932. static          boolean
  2933. DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
  2934.       bfd            *abfd AND
  2935.       sec_ptr         asect AND
  2936.       asymbol       **symbols)
  2937.   {
  2938.     RELOC   *native_relocs;
  2939.     arelent        *reloc_cache;
  2940.     if (asect->relocation)
  2941.       return true;
  2942.     if (asect->reloc_count == 0)
  2943.       return true;
  2944. #ifndef NO_COFF_SYMBOLS
  2945.     if (!coff_slurp_symbol_table(abfd))
  2946.       return false;
  2947. #endif
  2948.     native_relocs =
  2949.       (RELOC *) buy_and_read(abfd,
  2950.                  asect->rel_filepos,
  2951.                  SEEK_SET,
  2952.                  (size_t) (RELSZ *
  2953.                        asect->reloc_count));
  2954.     reloc_cache = (arelent *)
  2955.       bfd_alloc(abfd, (size_t) (asect->reloc_count * sizeof(arelent)));
  2956.     
  2957.     if (reloc_cache == NULL) {
  2958.       bfd_error = no_memory;
  2959.       return false;
  2960.     } {                /* on error */
  2961.       arelent        *cache_ptr;
  2962.       RELOC   *src;
  2963.       for (cache_ptr = reloc_cache,
  2964.        src = native_relocs;
  2965.        cache_ptr < reloc_cache + asect->reloc_count;
  2966.        cache_ptr++,
  2967.        src++) {
  2968.     struct internal_reloc dst;
  2969.     asymbol        *ptr;
  2970.     bfd_swap_reloc_in(abfd, src, &dst);
  2971.     
  2972.     dst.r_symndx += obj_symbol_slew(abfd);
  2973.     cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
  2974. #ifdef A29K 
  2975.     /* AMD has two relocation entries for the 'consth' instruction.
  2976.      * The first is R_IHIHALF (part 1), the second is R_IHCONST
  2977.      * (part 2).  The second entry's r_symndx does not contain
  2978.      * an index to a symbol but rather a value (apparently).
  2979.      * Also, see the ifdef below for saving the r_symndx value in addend.
  2980.      */
  2981.     if (dst.r_type == R_IHCONST)  {
  2982.         ptr = NULL;
  2983.     } else
  2984. #endif
  2985.     ptr = *(cache_ptr->sym_ptr_ptr);
  2986.     cache_ptr->address = dst.r_vaddr;
  2987.     /*
  2988.       The symbols definitions that we have read in have been
  2989.       relocated as if their sections started at 0. But the offsets
  2990.       refering to the symbols in the raw data have not been
  2991.       modified, so we have to have a negative addend to compensate.
  2992.       
  2993.       Note that symbols which used to be common must be left alone
  2994.       */
  2995.     
  2996.     if (ptr && ptr->the_bfd == abfd 
  2997.         && ptr->section != (asection *) NULL 
  2998.         && ((ptr->flags & BSF_OLD_COMMON)== 0)) 
  2999.         {
  3000. #ifndef M88
  3001.           cache_ptr->addend = -(ptr->section->vma + ptr->value);
  3002. #else
  3003.           cache_ptr->addend = 0;
  3004. #endif
  3005.  
  3006.         }
  3007.     else {
  3008.       cache_ptr->addend = 0;
  3009.     }
  3010.     
  3011.     cache_ptr->address -= asect->vma;
  3012.     
  3013.     cache_ptr->section = (asection *) NULL;
  3014.  
  3015. #ifdef A29K 
  3016.         if (dst.r_type == R_IHCONST) {
  3017.           /* Add in the value which was stored in the symbol index */
  3018.       /* See above comment */
  3019.           cache_ptr->addend += dst.r_symndx;
  3020.           /* Throw away the bogus symbol pointer */
  3021.           cache_ptr->sym_ptr_ptr = 0;
  3022.         }
  3023.     cache_ptr->howto = howto_table + dst.r_type;
  3024. #endif
  3025. #if I386
  3026.     cache_ptr->howto = howto_table + dst.r_type;
  3027. #endif
  3028. #if I960
  3029.     cache_ptr->howto = howto_table + dst.r_type;
  3030. #endif
  3031. #if M68
  3032.     cache_ptr->howto = howto_table + dst.r_type - R_RELBYTE;
  3033. #endif
  3034. #if M88
  3035.     if (dst.r_type >= R_PCR16L && dst.r_type <= R_VRT32) {
  3036.       cache_ptr->howto = howto_table + dst.r_type - R_PCR16L;
  3037.       cache_ptr->addend += dst.r_offset << 16;
  3038.     }
  3039.     else {
  3040.       BFD_ASSERT(0);
  3041.     }
  3042. #endif
  3043.     
  3044.       }
  3045.       
  3046.     }
  3047.     
  3048.     asect->relocation = reloc_cache;
  3049.     return true;
  3050.   }
  3051.  
  3052.  
  3053. /* This is stupid.  This function should be a boolean predicate */
  3054. static unsigned int
  3055. coff_canonicalize_reloc(abfd, section, relptr, symbols)
  3056. bfd            *abfd;
  3057. sec_ptr         section;
  3058. arelent       **relptr;
  3059. asymbol       **symbols;
  3060.   {
  3061.     arelent        *tblptr = section->relocation;
  3062.     unsigned int    count = 0;
  3063.     if (!(tblptr || coff_slurp_reloc_table(abfd, section, symbols)))
  3064.       return 0;
  3065.     tblptr = section->relocation;
  3066.     if (!tblptr)
  3067.       return 0;
  3068.     
  3069.     for (; count++ < section->reloc_count;)
  3070.       *relptr++ = tblptr++;
  3071.     
  3072.     *relptr = 0;
  3073.     
  3074.     return section->reloc_count;
  3075.   }
  3076.  
  3077. #ifndef NO_COFF_SYMBOLS
  3078.  
  3079. /*
  3080. provided a bfd, a section and an offset into the section, calculate and
  3081. return the name of the source file and the line nearest to the wanted
  3082. location.
  3083. */
  3084.  
  3085. static          boolean
  3086. DEFUN(coff_find_nearest_line,(abfd,
  3087.                   section,
  3088.                   symbols,
  3089.                   offset,
  3090.                   filename_ptr,
  3091.                   functionname_ptr,
  3092.                   line_ptr),
  3093.       bfd            *abfd AND
  3094.       asection       *section AND
  3095.       asymbol       **symbols AND
  3096.       bfd_vma         offset AND
  3097.       CONST char      **filename_ptr AND
  3098.       CONST char       **functionname_ptr AND
  3099.       unsigned int   *line_ptr)
  3100. {
  3101.   static bfd     *cache_abfd;
  3102.   static asection *cache_section;
  3103.   static bfd_vma  cache_offset;
  3104.   static unsigned int cache_i;
  3105.   static alent   *cache_l;
  3106.     
  3107.   unsigned int    i = 0;
  3108.   struct icofdata *cof = obj_icof(abfd);
  3109.   /* Run through the raw syments if available */
  3110.   combined_entry_type *p;
  3111.   alent          *l;
  3112.   unsigned int    line_base = 0;
  3113.     
  3114.     
  3115.   *filename_ptr = 0;
  3116.   *functionname_ptr = 0;
  3117.   *line_ptr = 0;
  3118.     
  3119.   /* Don't try and find line numbers in a non coff file */
  3120.   if (abfd->xvec->flavour != bfd_target_coff_flavour_enum)
  3121.     return false;
  3122.     
  3123.   if (cof == (struct icofdata *)NULL)
  3124.     return false;
  3125.  
  3126.   p = cof->raw_syments;
  3127.     
  3128.   for (i = 0; i < cof->raw_syment_count; i++) {
  3129.     if (p->u.syment.n_sclass == C_FILE) {
  3130.       /* File name has been moved into symbol */
  3131.       *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
  3132.       break;
  3133.     }
  3134.     p += 1 +  p->u.syment.n_numaux;
  3135.   }
  3136.   /* Now wander though the raw linenumbers of the section */
  3137.   /*
  3138.     If this is the same bfd as we were previously called with and this is
  3139.     the same section, and the offset we want is further down then we can
  3140.     prime the lookup loop
  3141.     */
  3142.   if (abfd == cache_abfd &&
  3143.       section == cache_section &&
  3144.       offset >= cache_offset) {
  3145.     i = cache_i;
  3146.     l = cache_l;
  3147.   }
  3148.   else {
  3149.     i = 0;
  3150.     l = section->lineno;
  3151.   }
  3152.     
  3153.   for (; i < section->lineno_count; i++) {
  3154.     if (l->line_number == 0) {
  3155.       /* Get the symbol this line number points at */
  3156.       coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
  3157.       *functionname_ptr = coff->symbol.name;
  3158.       if (coff->native) {
  3159.     combined_entry_type  *s = coff->native;
  3160.     s = s + 1 + s->u.syment.n_numaux;
  3161.     /*
  3162.       S should now point to the .bf of the function
  3163.       */
  3164.     if (s->u.syment.n_numaux) {
  3165.       /*
  3166.         The linenumber is stored in the auxent
  3167.         */
  3168.       union internal_auxent   *a = &((s + 1)->u.auxent);
  3169.       line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
  3170.     }
  3171.       }
  3172.     }
  3173.     else {
  3174.       if (l->u.offset > offset)
  3175.     break;
  3176.       *line_ptr = l->line_number + line_base + 1;
  3177.     }
  3178.     l++;
  3179.   }
  3180.     
  3181.   cache_abfd = abfd;
  3182.   cache_section = section;
  3183.   cache_offset = offset;
  3184.   cache_i = i;
  3185.   cache_l = l;
  3186.  
  3187.   return true;
  3188. }
  3189.  
  3190. #ifdef GNU960
  3191. file_ptr
  3192. coff_sym_filepos(abfd)
  3193. bfd *abfd;
  3194.   {
  3195.     return obj_sym_filepos(abfd);
  3196.   }
  3197. #endif
  3198.  
  3199. #endif /* NO_COFF_SYMBOLS */
  3200.  
  3201.  
  3202. static int 
  3203. DEFUN(coff_sizeof_headers,(abfd, reloc),
  3204.       bfd *abfd AND
  3205.       boolean reloc)
  3206.   {
  3207.     size_t size;
  3208.     
  3209.     if (reloc == false) {
  3210.       size = FILHSZ + AOUTSZ;
  3211.     }
  3212.     else {
  3213.       size = FILHSZ;
  3214.     }
  3215.     
  3216.     size +=  abfd->section_count * SCNHSZ;
  3217.     return size;
  3218.   }
  3219.  
  3220.  
  3221. #define coff_core_file_failing_command    _bfd_dummy_core_file_failing_command
  3222. #define coff_core_file_failing_signal    _bfd_dummy_core_file_failing_signal
  3223. #define coff_core_file_matches_executable_p    _bfd_dummy_core_file_matches_executable_p
  3224. #define coff_slurp_armap        bfd_slurp_coff_armap
  3225. #define coff_slurp_extended_name_table    _bfd_slurp_extended_name_table
  3226. #define coff_truncate_arname        bfd_dont_truncate_arname
  3227. #define coff_openr_next_archived_file    bfd_generic_openr_next_archived_file
  3228. #define coff_generic_stat_arch_elt    bfd_generic_stat_arch_elt
  3229. #define    coff_get_section_contents    bfd_generic_get_section_contents
  3230. #define    coff_close_and_cleanup        bfd_generic_close_and_cleanup
  3231.  
  3232. #define coff_bfd_debug_info_start        bfd_void
  3233. #define coff_bfd_debug_info_end        bfd_void
  3234. #define coff_bfd_debug_info_accumulate    (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
  3235.  
  3236.